using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using R2API.Networking;
using R2API.Networking.Interfaces;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Navigation;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Stats;
using RoR2.UI;
using TMPro;
using Unity.Collections;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ScorchedVoxels")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.20.72.0")]
[assembly: AssemblyInformationalVersion("0.20.72+a4d65434dd33f229551efc8d9b06c8cae4d20476")]
[assembly: AssemblyProduct("ScorchedVoxels")]
[assembly: AssemblyTitle("ScorchedVoxels")]
[assembly: AssemblyVersion("0.20.72.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ScorchedVoxels
{
	internal class ArcadeColorGrid
	{
		private class Tile
		{
			public int idx;

			public UiTile ui;

			public Image sprite;

			public Image swatch;

			public UiKit.Label badge;
		}

		public const float TileW = 96f;

		public const float TileH = 112f;

		public const float Gap = 8f;

		private const float SpriteScale = 6f;

		private readonly List<Tile> tiles = new List<Tile>();

		private string profileKey;

		public Action onChanged;

		public int PickedCount => UserLifetimeStats.ArcadeColors(profileKey).Count;

		public float Build(RectTransform content, float contentW, string userProfileKey)
		{
			profileKey = userProfileKey;
			tiles.Clear();
			int num = Mathf.Max(2, Mathf.FloorToInt((contentW + 8f) / 104f));
			float num2 = (0f - ((float)num * 96f + (float)(num - 1) * 8f)) * 0.5f;
			for (int i = 0; i < 16; i++)
			{
				int num3 = i % num;
				int num4 = i / num;
				float x = num2 + (float)num3 * 104f + 48f;
				float y = 0f - ((float)num4 * 120f + 56f);
				tiles.Add(BuildTile(content, i, x, y));
			}
			Refresh();
			return (float)((16 + num - 1) / num) * 120f;
		}

		private Tile BuildTile(RectTransform content, int idx, float x, float y)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: 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_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			Tile tile = new Tile
			{
				idx = idx
			};
			tile.ui = new UiTile($"color_{idx}", content, new Vector2(96f, 112f), new Vector2(x, y), (UnityAction)delegate
			{
				OnTileClicked(idx);
			});
			GameObject val = new GameObject("commando");
			val.transform.SetParent(((Component)tile.ui.Face).transform, false);
			tile.sprite = val.AddComponent<Image>();
			((Graphic)tile.sprite).raycastTarget = false;
			RectTransform rectTransform = ((Graphic)tile.sprite).rectTransform;
			rectTransform.pivot = new Vector2(0.5f, 0f);
			rectTransform.anchorMin = new Vector2(0.5f, 0f);
			rectTransform.anchorMax = new Vector2(0.5f, 0f);
			rectTransform.sizeDelta = new Vector2(36f, 66f);
			rectTransform.anchoredPosition = new Vector2(0f, 26f);
			if (CommandoSprites.Ready)
			{
				tile.sprite.sprite = CommandoSprites.CommandoFrame(idx, 0f);
			}
			else
			{
				((Behaviour)tile.sprite).enabled = false;
				tile.swatch = UiKit.CreateImage("swatch", ((Component)tile.ui.Face).transform, CommandoSprites.Tint(idx));
				((Graphic)tile.swatch).raycastTarget = false;
				RectTransform rectTransform2 = ((Graphic)tile.swatch).rectTransform;
				rectTransform2.pivot = new Vector2(0.5f, 0f);
				rectTransform2.anchorMin = new Vector2(0.5f, 0f);
				rectTransform2.anchorMax = new Vector2(0.5f, 0f);
				rectTransform2.sizeDelta = new Vector2(36f, 66f);
				rectTransform2.anchoredPosition = new Vector2(0f, 26f);
			}
			UiKit.Label label = UiKit.CreateLabel($"label_{idx}", ((Component)tile.ui.Face).transform, 11f, UiKit.TextPale, (TextAnchor)4);
			label.Rect.anchorMin = new Vector2(0f, 0f);
			label.Rect.anchorMax = new Vector2(1f, 0f);
			label.Rect.pivot = new Vector2(0.5f, 0f);
			label.Rect.sizeDelta = new Vector2(-6f, 20f);
			label.Rect.anchoredPosition = new Vector2(0f, 3f);
			label.ClipSingleLine();
			label.Text = CommandoSprites.ColorwayNames[idx];
			tile.badge = UiKit.CreateLabel($"badge_{idx}", ((Component)tile.ui.Face).transform, 16f, UiKit.Gold, (TextAnchor)4);
			tile.badge.Rect.anchorMin = new Vector2(1f, 1f);
			tile.badge.Rect.anchorMax = new Vector2(1f, 1f);
			tile.badge.Rect.sizeDelta = new Vector2(22f, 22f);
			tile.badge.Rect.anchoredPosition = new Vector2(-14f, -14f);
			tile.badge.Bold();
			tile.badge.Text = "";
			return tile;
		}

		private void OnTileClicked(int idx)
		{
			List<int> list = new List<int>(UserLifetimeStats.ArcadeColors(profileKey));
			if (list.Contains(idx))
			{
				list.Remove(idx);
			}
			else if (list.Count < 3)
			{
				list.Add(idx);
			}
			else
			{
				list[2] = idx;
			}
			UserLifetimeStats.SetArcadeColors(profileKey, list);
			Refresh();
			onChanged?.Invoke();
		}

		public void Refresh()
		{
			IReadOnlyList<int> readOnlyList = UserLifetimeStats.ArcadeColors(profileKey);
			foreach (Tile tile in tiles)
			{
				int num = -1;
				for (int i = 0; i < readOnlyList.Count; i++)
				{
					if (readOnlyList[i] == tile.idx)
					{
						num = i;
						break;
					}
				}
				tile.ui.Selected = num == 0;
				tile.badge.Text = ((num >= 0) ? (num + 1).ToString() : "");
			}
		}

		public void Tick()
		{
			if (!CommandoSprites.Ready)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			foreach (Tile tile in tiles)
			{
				tile.sprite.sprite = CommandoSprites.CommandoFrame(tile.idx, unscaledTime);
				if (!((Behaviour)tile.sprite).enabled)
				{
					((Behaviour)tile.sprite).enabled = true;
				}
				if ((Object)(object)tile.swatch != (Object)null && ((Behaviour)tile.swatch).enabled)
				{
					((Behaviour)tile.swatch).enabled = false;
				}
			}
		}
	}
	internal static class ArcadeTheming
	{
		public static string DestinationScene;
	}
	internal static class ArcadeLocal
	{
		public static NetworkUser User()
		{
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					return readOnlyInstances;
				}
			}
			return null;
		}

		public static string ProfileKey()
		{
			NetworkUser val = User();
			if (!((Object)(object)val == (Object)null))
			{
				return UserLifetimeStats.ProfileKey(val);
			}
			return null;
		}

		public static uint NetId()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			NetworkUser val = User();
			if (!((Object)(object)val == (Object)null))
			{
				NetworkInstanceId netId = ((NetworkBehaviour)val).netId;
				return ((NetworkInstanceId)(ref netId)).Value;
			}
			return 0u;
		}

		public static int PreferredColorway()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			NetworkUser val = User();
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			IReadOnlyList<int> readOnlyList = UserLifetimeStats.ArcadeColors(val);
			if (readOnlyList != null && readOnlyList.Count > 0)
			{
				return readOnlyList[0];
			}
			NetworkInstanceId netId = ((NetworkBehaviour)val).netId;
			return CommandoSprites.ColorwayFor(((NetworkInstanceId)(ref netId)).Value);
		}
	}
	internal static class ArcadeRng
	{
		public static uint Step(ref uint state)
		{
			uint num = state;
			num ^= num << 13;
			num ^= num >> 17;
			num ^= num << 5;
			return state = num;
		}

		public static int Next(ref uint state, int maxExclusive)
		{
			return (int)(Step(ref state) % (uint)maxExclusive);
		}
	}
	internal class ArcadeContext
	{
		public uint seed;

		public RectTransform panel;

		public float width;

		public float height;

		public WormsGame.MatchConfig wormsMatch;

		public RaceGame.MatchConfig raceMatch;
	}
	internal interface IMiniGame
	{
		void Start(ArcadeContext ctx);

		void Tick(float dt);

		void End();
	}
	internal static class ArcadeInput
	{
		public static bool Blocked;

		public static bool ActionDown;

		public static bool ActionHeld;

		public static bool RopeDown;

		public static bool RopeHeld;

		public static bool DuckHeld;

		public static bool ToggleDown;

		public static void Poll(RectTransform clickArea)
		{
			//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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (Blocked)
			{
				ActionDown = (ActionHeld = (RopeDown = (RopeHeld = (DuckHeld = (ToggleDown = false)))));
				return;
			}
			ActionDown = Input.GetKeyDown((KeyCode)32) || Input.GetKeyDown((KeyCode)119) || Input.GetKeyDown((KeyCode)273) || (Input.GetMouseButtonDown(0) && inArea(Vector2.op_Implicit(Input.mousePosition)));
			ActionHeld = Input.GetKey((KeyCode)32) || Input.GetKey((KeyCode)119) || Input.GetKey((KeyCode)273) || Input.GetMouseButton(0);
			RopeDown = Input.GetKeyDown((KeyCode)115) || Input.GetKeyDown((KeyCode)274) || Input.GetKeyDown((KeyCode)306) || (Input.GetMouseButtonDown(1) && inArea(Vector2.op_Implicit(Input.mousePosition)));
			RopeHeld = Input.GetKey((KeyCode)115) || Input.GetKey((KeyCode)274) || Input.GetKey((KeyCode)306) || Input.GetMouseButton(1);
			DuckHeld = Input.GetKey((KeyCode)115) || Input.GetKey((KeyCode)274) || Input.GetKey((KeyCode)306);
			ToggleDown = Input.GetKeyDown((KeyCode)103);
			bool inArea(Vector2 p)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)clickArea != (Object)null)
				{
					return RectTransformUtility.RectangleContainsScreenPoint(clickArea, p);
				}
				return false;
			}
		}
	}
	internal static class ArcadeHost
	{
		internal enum GameKind
		{
			Runner,
			Worms,
			Race,
			Terrarium
		}

		private abstract class MatchChannel
		{
			protected const float ResendSeconds = 2f;

			protected const float HostSilenceFoldSeconds = 8f;

			protected readonly bool hostLive;

			protected float nextResendAt;

			protected float lastHostMsgAt;

			protected abstract uint HostMatchId { get; }

			protected abstract uint RunningMatchId { get; }

			protected abstract bool JoinPending { get; }

			protected MatchChannel(bool hostLive)
			{
				this.hostLive = hostLive;
				lastHostMsgAt = Time.unscaledTime;
			}

			protected abstract void StartPendingGame();

			protected abstract void SendAnnounce();

			protected abstract void SendTeardown();

			protected abstract void HostTickCanon();

			protected abstract void Close();

			public void StampHostMsg()
			{
				lastHostMsgAt = Time.unscaledTime;
			}

			public void Tick()
			{
				if (JoinPending)
				{
					if (!uiBuilt)
					{
						return;
					}
					StartPendingGame();
				}
				if (!NetworkServer.active)
				{
					if (RunningMatchId != 0 && Time.unscaledTime - lastHostMsgAt > 8f)
					{
						Close();
						FoldLocalMatch();
					}
				}
				else
				{
					if (!hostLive)
					{
						return;
					}
					if (RunningMatchId != HostMatchId)
					{
						SendTeardown();
						Close();
						return;
					}
					HostTickCanon();
					if (Time.unscaledTime >= nextResendAt)
					{
						nextResendAt = Time.unscaledTime + 2f;
						SendAnnounce();
					}
				}
			}
		}

		private sealed class WormsChannel : MatchChannel
		{
			private readonly WormsGame.MatchConfig hostCfg;

			private WormsGame.MatchConfig pendingCfg;

			private WormsShot[] pendingShots;

			private readonly List<WormsShot> shotLog = new List<WormsShot>();

			private WormsShot[] shotLogCache = Array.Empty<WormsShot>();

			private readonly List<WormsShot> requestQueue = new List<WormsShot>();

			private readonly HashSet<uint> forfeited = new HashSet<uint>();

			private int timedShotCount = -1;

			private float turnDeadlineAt;

			protected override uint HostMatchId => hostCfg.matchId;

			protected override uint RunningMatchId
			{
				get
				{
					if (!(game is WormsGame wormsGame))
					{
						return 0u;
					}
					return wormsGame.MatchId;
				}
			}

			protected override bool JoinPending => pendingCfg != null;

			private WormsChannel(bool hostLive, WormsGame.MatchConfig hostCfg)
				: base(hostLive)
			{
				this.hostCfg = hostCfg;
			}

			public static WormsChannel Host(WormsGame.MatchConfig cfg)
			{
				return new WormsChannel(hostLive: true, cfg);
			}

			public static WormsChannel Join(WormsGame.MatchConfig cfg, WormsShot[] shots)
			{
				WormsChannel wormsChannel = new WormsChannel(hostLive: false, null);
				if (uiBuilt)
				{
					StartGame(GameKind.Worms, cfg, null);
					if (game is WormsGame wormsGame)
					{
						wormsGame.CatchUp(shots);
					}
				}
				else
				{
					wormsChannel.pendingCfg = cfg;
					wormsChannel.pendingShots = shots;
				}
				return wormsChannel;
			}

			public bool OwnsMatch(uint matchId)
			{
				if (hostLive)
				{
					return hostCfg.matchId == matchId;
				}
				return false;
			}

			protected override void StartPendingGame()
			{
				WormsGame.MatchConfig matchCfg = pendingCfg;
				WormsShot[] array = pendingShots;
				pendingCfg = null;
				pendingShots = null;
				StartGame(GameKind.Worms, matchCfg, null);
				if (game is WormsGame wormsGame && array != null)
				{
					wormsGame.CatchUp(array);
				}
			}

			protected override void SendAnnounce()
			{
				if (shotLogCache.Length != shotLog.Count)
				{
					shotLogCache = shotLog.ToArray();
				}
				NetMessageExtensions.Send((INetMessage)(object)new WormsMatchMessage(hostCfg.matchId, hostCfg.seed, hostCfg.ids, hostCfg.colorways, shotLogCache), (NetworkDestination)1);
			}

			protected override void SendTeardown()
			{
				NetMessageExtensions.Send((INetMessage)(object)new WormsMatchMessage(0u, 0u, Array.Empty<uint>(), Array.Empty<byte>(), Array.Empty<WormsShot>()), (NetworkDestination)1);
			}

			protected override void HostTickCanon()
			{
				//IL_0098: 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)
				WormsGame wormsGame = (WormsGame)game;
				if (wormsGame.MatchOver)
				{
					requestQueue.Clear();
					return;
				}
				while (!wormsGame.InFlight && !wormsGame.MatchOver && requestQueue.Count > 0)
				{
					WormsShot shot = requestQueue[0];
					requestQueue.RemoveAt(0);
					HostApplyShot(shot);
				}
				if (wormsGame.MatchOver)
				{
					return;
				}
				uint currentTurnOwner = wormsGame.CurrentTurnOwner;
				if (currentTurnOwner != 0)
				{
					bool flag = false;
					foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
					{
						if ((Object)(object)readOnlyInstances != (Object)null)
						{
							NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
							if (((NetworkInstanceId)(ref netId)).Value == currentTurnOwner)
							{
								flag = true;
								break;
							}
						}
					}
					if (!flag && forfeited.Add(currentTurnOwner))
					{
						HostApplyShot(new WormsShot
						{
							shooterNetId = currentTurnOwner,
							weapon = 254
						});
					}
				}
				if (wormsGame.InFlight || wormsGame.KnownShotCount != timedShotCount)
				{
					timedShotCount = wormsGame.KnownShotCount;
					turnDeadlineAt = Time.unscaledTime + 45f;
				}
				else if (currentTurnOwner != 0 && Time.unscaledTime >= turnDeadlineAt)
				{
					HostApplyShot(new WormsShot
					{
						shooterNetId = currentTurnOwner,
						weapon = byte.MaxValue
					});
				}
			}

			protected override void Close()
			{
				wormsChannel = null;
			}

			public void HostApplyClientRequest(WormsShot shot)
			{
				//IL_0024: 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)
				if (!WormsGame.ValidWeaponByte(shot.weapon))
				{
					return;
				}
				NetworkUser val = ArcadeLocal.User();
				if ((Object)(object)val != (Object)null)
				{
					uint shooterNetId = shot.shooterNetId;
					NetworkInstanceId netId = ((NetworkBehaviour)val).netId;
					if (shooterNetId == ((NetworkInstanceId)(ref netId)).Value)
					{
						return;
					}
				}
				HostApplyShot(shot);
			}

			public void HostApplyShot(WormsShot shot)
			{
				if (!hostLive || !(game is WormsGame wormsGame) || wormsGame.MatchId != hostCfg.matchId || wormsGame.MatchOver || (shot.weapon != byte.MaxValue && shot.weapon != 254 && !WormsGame.ValidWeaponByte(shot.weapon)))
				{
					return;
				}
				if (wormsGame.InFlight)
				{
					for (int num = requestQueue.Count - 1; num >= 0; num--)
					{
						if (requestQueue[num].shooterNetId == shot.shooterNetId && requestQueue[num].weapon != 254)
						{
							requestQueue.RemoveAt(num);
						}
					}
					requestQueue.Add(shot);
				}
				else if (shot.weapon == 254 || shot.shooterNetId == wormsGame.CurrentTurnOwner)
				{
					int count = shotLog.Count;
					shotLog.Add(shot);
					wormsGame.ApplyShot(shot, animate: true);
					NetMessageExtensions.Send((INetMessage)(object)new WormsShotMessage(hostCfg.matchId, (ushort)count, shot), (NetworkDestination)1);
				}
			}
		}

		private sealed class RaceChannel : MatchChannel
		{
			private readonly RaceGame.MatchConfig hostCfg;

			private RaceGame.MatchConfig pendingCfg;

			private float roundBumpAt;

			protected override uint HostMatchId => hostCfg.matchId;

			protected override uint RunningMatchId
			{
				get
				{
					if (!(game is RaceGame raceGame))
					{
						return 0u;
					}
					return raceGame.MatchId;
				}
			}

			protected override bool JoinPending => pendingCfg != null;

			private RaceChannel(bool hostLive, RaceGame.MatchConfig hostCfg)
				: base(hostLive)
			{
				this.hostCfg = hostCfg;
			}

			public static RaceChannel Host(RaceGame.MatchConfig cfg)
			{
				return new RaceChannel(hostLive: true, cfg);
			}

			public static RaceChannel Join(RaceGame.MatchConfig cfg)
			{
				RaceChannel raceChannel = new RaceChannel(hostLive: false, null);
				if (uiBuilt)
				{
					StartGame(GameKind.Race, null, cfg);
				}
				else
				{
					raceChannel.pendingCfg = cfg;
				}
				return raceChannel;
			}

			protected override void StartPendingGame()
			{
				RaceGame.MatchConfig raceCfg = pendingCfg;
				pendingCfg = null;
				StartGame(GameKind.Race, null, raceCfg);
			}

			protected override void SendAnnounce()
			{
				NetMessageExtensions.Send((INetMessage)(object)new RaceMatchMessage(hostCfg.matchId, hostCfg.seed, hostCfg.round, hostCfg.ids, hostCfg.colorways, hostCfg.wins), (NetworkDestination)1);
			}

			protected override void SendTeardown()
			{
				NetMessageExtensions.Send((INetMessage)(object)new RaceMatchMessage(0u, 0u, 0, Array.Empty<uint>(), Array.Empty<byte>(), Array.Empty<byte>()), (NetworkDestination)1);
			}

			protected override void HostTickCanon()
			{
				RaceGame raceGame = (RaceGame)game;
				if (raceGame.TryTakeRoundWinner(out var winner))
				{
					for (int i = 0; i < hostCfg.ids.Length; i++)
					{
						if (hostCfg.ids[i] == winner && hostCfg.wins[i] < byte.MaxValue)
						{
							hostCfg.wins[i]++;
						}
					}
					raceGame.ApplyMatchState(hostCfg.round, hostCfg.wins);
					roundBumpAt = Time.unscaledTime + 3f;
					nextResendAt = 0f;
				}
				if (roundBumpAt > 0f && Time.unscaledTime >= roundBumpAt)
				{
					roundBumpAt = 0f;
					hostCfg.round++;
					raceGame.ApplyMatchState(hostCfg.round, hostCfg.wins);
					nextResendAt = 0f;
				}
			}

			protected override void Close()
			{
				raceChannel = null;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__ToggleColorPanel;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Action <>9__50_0;

			public static UnityAction <>9__51_0;

			public static UnityAction <>9__51_1;

			public static UnityAction <>9__51_2;

			public static UnityAction <>9__51_3;

			public static UnityAction <>9__51_4;

			internal void <ToggleColorPanel>b__50_0()
			{
				if (colorCount != null)
				{
					colorCount.Text = $"{colorGrid.PickedCount} / 3 picked";
				}
			}

			internal void <BuildUi>b__51_0()
			{
				StartOrStop(GameKind.Runner);
			}

			internal void <BuildUi>b__51_1()
			{
				StartOrStop(GameKind.Race);
			}

			internal void <BuildUi>b__51_2()
			{
				StartOrStop(GameKind.Worms);
			}

			internal void <BuildUi>b__51_3()
			{
				StartOrStop(GameKind.Terrarium);
			}

			internal void <BuildUi>b__51_4()
			{
				holdEngaged = !holdEngaged;
				holdBtn.Text = (holdEngaged ? "UNLOCK LOADING" : "LOCK LOADING");
			}
		}

		private const float ButtonH = 30f;

		internal const float RunnerStripH = 150f;

		internal const float RunnerSoloW = 480f;

		private const float WormsStripW = 1100f;

		private const float WormsStripH = 185f;

		private const float RaceStripW = 1100f;

		private const float RaceStripH = 208f;

		private const float TankStripW = 700f;

		private const float TankStripH = 185f;

		private const float StripBottomLimit = -408f;

		internal const float CeremonyGraceSeconds = 3f;

		private const float ReelArrivalGrace = 1.5f;

		private static float lastLotteryAt = -1f;

		private static bool holdEngaged;

		private static UiKit.Btn holdBtn;

		private static GameKind activeKind;

		private static GameKind lastKind = GameKind.Runner;

		private static float stripH = 150f;

		private static float btnNoteUntil;

		private static UiKit.Btn btnNoteOn;

		private static string btnNotePrior;

		private static GameObject root;

		private static float attachedAt;

		private static bool uiBuilt;

		private static UiKit.Btn playBtn;

		private static UiKit.Btn raceBtn;

		private static UiKit.Btn wormsBtn;

		private static UiKit.Btn tankBtn;

		private static UiKit.Btn colorsBtn;

		private static GameObject colorPanel;

		private static ArcadeColorGrid colorGrid;

		private static UiKit.Label colorCount;

		private static GameObject strip;

		private static RectTransform stripRect;

		private static RectTransform stripContent;

		private static IMiniGame game;

		private static float matchStartedAt;

		private const float StopArmSeconds = 0.75f;

		private static WormsChannel wormsChannel;

		private static RaceChannel raceChannel;

		public static bool CeremonyClosed { get; private set; }

		public static bool HoldingLoadingScreen
		{
			get
			{
				if ((Object)(object)root != (Object)null && uiBuilt)
				{
					return holdEngaged;
				}
				return false;
			}
		}

		public static bool StripOpen => (Object)(object)strip != (Object)null;

		public static float StripReserve
		{
			get
			{
				if (!((Object)(object)strip != (Object)null))
				{
					return 0f;
				}
				return stripH + 44f;
			}
		}

		public static void Attach(GameObject overlayRoot)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			CeremonyClosed = false;
			lastLotteryAt = -1f;
			uiBuilt = false;
			holdEngaged = false;
			attachedAt = Time.unscaledTime;
			root = new GameObject("arcade");
			root.transform.SetParent(overlayRoot.transform, false);
			UiKit.Stretch(root.AddComponent<RectTransform>());
			if (ModOptions.ArcadeEnabled.Value)
			{
				CommandoSprites.EnsureLoading();
				WeaponIcons.EnsureLoading();
			}
		}

		public static void Detach()
		{
			EndGame();
			SpectateStrips.Clear();
			TerrariumStrips.Clear();
			ArcadeSpectate.Clear();
			RaceSpectate.Clear();
			TerrariumNet.Clear();
			DropMatchChannels();
			RaceSpectate.ActiveMatchId = 0u;
			btnNoteUntil = 0f;
			btnNoteOn = null;
			btnNotePrior = null;
			matchStartedAt = 0f;
			root = null;
			playBtn = null;
			raceBtn = null;
			wormsBtn = null;
			tankBtn = null;
			colorsBtn = null;
			colorPanel = null;
			colorGrid = null;
			colorCount = null;
			holdBtn = null;
			strip = null;
			stripRect = null;
			stripContent = null;
			uiBuilt = false;
			holdEngaged = false;
			CeremonyClosed = false;
			lastLotteryAt = -1f;
		}

		public static void Tick()
		{
			if ((Object)(object)root == (Object)null || !ModOptions.ArcadeEnabled.Value)
			{
				return;
			}
			int num;
			if (!CeremonyClosed)
			{
				if (!LoadingOverlay.AnyReelAwaitingShow)
				{
					num = (LoadingOverlay.AnyReelLive ? 1 : 0);
					if (num == 0)
					{
						goto IL_003d;
					}
				}
				else
				{
					num = 1;
				}
				lastLotteryAt = Time.unscaledTime;
				goto IL_003d;
			}
			goto IL_0098;
			IL_003d:
			float num2 = ((num != 0) ? float.MaxValue : ((!(lastLotteryAt >= 0f)) ? ((NetworkUser.readOnlyInstancesList.Count > 1) ? (attachedAt + 1.5f) : attachedAt) : lastLotteryAt));
			if (Time.unscaledTime < num2)
			{
				return;
			}
			CeremonyClosed = true;
			CommandoSprites.EnsureLoading();
			WeaponIcons.EnsureLoading();
			goto IL_0098;
			IL_0098:
			if (CommandoSprites.Failed)
			{
				return;
			}
			if (!uiBuilt)
			{
				if (!CommandoSprites.Ready)
				{
					return;
				}
				BuildUi();
			}
			PositionUi();
			if (holdBtn != null)
			{
				bool flag = NetworkUser.readOnlyInstancesList.Count <= 1 || NetworkServer.active;
				if (holdBtn.Go.activeSelf != flag)
				{
					holdBtn.Go.SetActive(flag);
				}
			}
			ArcadeInput.Blocked = (Object)(object)colorPanel != (Object)null;
			ArcadeInput.Poll(stripContent);
			bool flag2 = game is WormsGame { MatchId: not 0u } || (game is RaceGame raceGame && raceGame.MatchId != 0);
			bool flag3 = (lastKind == GameKind.Worms || lastKind == GameKind.Race) && NetworkUser.readOnlyInstancesList.Count > 1;
			if (ArcadeInput.ToggleDown && !flag2 && !flag3)
			{
				StartOrStop(lastKind);
			}
			colorGrid?.Tick();
			SpectateStrips.Tick();
			TerrariumStrips.Tick();
			if (game != null && ((Object)(object)colorPanel == (Object)null || flag2))
			{
				game.Tick(Mathf.Min(Time.unscaledDeltaTime, 0.05f));
			}
			TickButtonNote();
			TickMatchChannels();
		}

		private static void ToggleColorPanel()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00dc: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)colorPanel != (Object)null)
			{
				Object.Destroy((Object)(object)colorPanel);
				colorPanel = null;
				colorGrid = null;
				colorCount = null;
				return;
			}
			string text = ArcadeLocal.ProfileKey() ?? UserLifetimeStats.ProfileKey(LocalUserManager.GetFirstLocalUser());
			if (text == null)
			{
				return;
			}
			colorPanel = new GameObject("arcadeColorModal");
			colorPanel.transform.SetParent(root.transform, false);
			UiKit.Stretch(colorPanel.AddComponent<RectTransform>());
			Image obj = UiKit.CreateImage("dim", colorPanel.transform, new Color(0f, 0f, 0f, 0.55f));
			UiKit.Stretch(((Graphic)obj).rectTransform);
			ButtonClickedEvent onClick = ((Component)obj).gameObject.AddComponent<Button>().onClick;
			object obj2 = <>O.<0>__ToggleColorPanel;
			if (obj2 == null)
			{
				UnityAction val = ToggleColorPanel;
				<>O.<0>__ToggleColorPanel = val;
				obj2 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj2);
			UiWindow uiWindow = new UiWindow("panel", colorPanel.transform, UiKit.PanelSolid, UiKit.OutlineBright);
			GameObject go = uiWindow.Go;
			RectTransform rect = uiWindow.Rect;
			Transform transform = go.transform;
			Vector2 size = new Vector2(26f, 26f);
			object obj3 = <>O.<0>__ToggleColorPanel;
			if (obj3 == null)
			{
				UnityAction val2 = ToggleColorPanel;
				<>O.<0>__ToggleColorPanel = val2;
				obj3 = (object)val2;
			}
			UiKit.Btn btn = UiKit.CreateButton("close", transform, size, 14f, "X", (UnityAction)obj3);
			btn.Rect.anchorMin = new Vector2(1f, 1f);
			btn.Rect.anchorMax = new Vector2(1f, 1f);
			btn.Rect.pivot = new Vector2(1f, 1f);
			btn.Rect.anchoredPosition = new Vector2(-6f, -6f);
			UiKit.Label label = UiKit.CreateLabel("header", go.transform, 17f, UiKit.HeaderTan, (TextAnchor)3);
			label.Rect.anchorMin = new Vector2(0f, 1f);
			label.Rect.anchorMax = new Vector2(1f, 1f);
			label.Rect.pivot = new Vector2(0.5f, 1f);
			label.Rect.sizeDelta = new Vector2(-28f, 36f);
			label.Rect.anchoredPosition = new Vector2(0f, -2f);
			label.Bold();
			label.Text = "ARCADE COLORS";
			colorCount = UiKit.CreateLabel("count", go.transform, 12f, UiKit.TextDim, (TextAnchor)5);
			colorCount.Rect.anchorMin = new Vector2(0f, 1f);
			colorCount.Rect.anchorMax = new Vector2(1f, 1f);
			colorCount.Rect.pivot = new Vector2(0.5f, 1f);
			colorCount.Rect.sizeDelta = new Vector2(-88f, 36f);
			colorCount.Rect.anchoredPosition = new Vector2(-30f, -2f);
			GameObject val3 = new GameObject("content");
			val3.transform.SetParent(go.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0.5f, 1f);
			val4.anchorMax = new Vector2(0.5f, 1f);
			val4.pivot = new Vector2(0.5f, 1f);
			val4.anchoredPosition = new Vector2(0f, -40f);
			colorGrid = new ArcadeColorGrid();
			colorGrid.onChanged = delegate
			{
				if (colorCount != null)
				{
					colorCount.Text = $"{colorGrid.PickedCount} / 3 picked";
				}
			};
			float num = colorGrid.Build(val4, 408f, text);
			val4.sizeDelta = new Vector2(408f, num);
			colorCount.Text = $"{colorGrid.PickedCount} / 3 picked";
			rect.sizeDelta = new Vector2(436f, 40f + num + 14f);
			rect.anchoredPosition = new Vector2(0f, 40f);
		}

		private static void BuildUi()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_010e: 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_00eb: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_023f: 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_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			uiBuilt = true;
			GameObject gameObject = ((Component)root.transform.parent).gameObject;
			if ((Object)(object)gameObject.GetComponent<GraphicRaycaster>() == (Object)null)
			{
				gameObject.AddComponent<GraphicRaycaster>();
			}
			if ((Object)(object)gameObject.GetComponent<CursorOpener>() == (Object)null)
			{
				gameObject.AddComponent<MPEventSystemProvider>();
				gameObject.AddComponent<MPEventSystemLocator>();
				gameObject.AddComponent<CursorOpener>();
			}
			Transform transform = root.transform;
			Vector2 size = new Vector2(110f, 30f);
			object obj = <>c.<>9__51_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					StartOrStop(GameKind.Runner);
				};
				<>c.<>9__51_0 = val;
				obj = (object)val;
			}
			playBtn = UiKit.CreateButton("arcadeRunner", transform, size, 11f, "RUNNER", (UnityAction)obj);
			Transform transform2 = root.transform;
			Vector2 size2 = new Vector2(110f, 30f);
			object obj2 = <>c.<>9__51_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					StartOrStop(GameKind.Race);
				};
				<>c.<>9__51_1 = val2;
				obj2 = (object)val2;
			}
			raceBtn = UiKit.CreateButton("arcadeRace", transform2, size2, 11f, "RACE", (UnityAction)obj2);
			Transform transform3 = root.transform;
			Vector2 size3 = new Vector2(110f, 30f);
			object obj3 = <>c.<>9__51_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					StartOrStop(GameKind.Worms);
				};
				<>c.<>9__51_2 = val3;
				obj3 = (object)val3;
			}
			wormsBtn = UiKit.CreateButton("arcadeWorms", transform3, size3, 11f, "WORMS", (UnityAction)obj3);
			Transform transform4 = root.transform;
			Vector2 size4 = new Vector2(110f, 30f);
			object obj4 = <>c.<>9__51_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					StartOrStop(GameKind.Terrarium);
				};
				<>c.<>9__51_3 = val4;
				obj4 = (object)val4;
			}
			tankBtn = UiKit.CreateButton("arcadeTank", transform4, size4, 11f, "TANK", (UnityAction)obj4);
			Transform transform5 = root.transform;
			Vector2 size5 = new Vector2(110f, 30f);
			object obj5 = <>O.<0>__ToggleColorPanel;
			if (obj5 == null)
			{
				UnityAction val5 = ToggleColorPanel;
				<>O.<0>__ToggleColorPanel = val5;
				obj5 = (object)val5;
			}
			colorsBtn = UiKit.CreateButton("arcadeColors", transform5, size5, 11f, "COLORS", (UnityAction)obj5);
			Transform transform6 = root.transform;
			Vector2 size6 = new Vector2(150f, 26f);
			object obj6 = <>c.<>9__51_4;
			if (obj6 == null)
			{
				UnityAction val6 = delegate
				{
					holdEngaged = !holdEngaged;
					holdBtn.Text = (holdEngaged ? "UNLOCK LOADING" : "LOCK LOADING");
				};
				<>c.<>9__51_4 = val6;
				obj6 = (object)val6;
			}
			holdBtn = UiKit.CreateButton("arcadeLock", transform6, size6, 13f, "LOCK LOADING", (UnityAction)obj6);
			holdBtn.Rect.anchorMin = Vector2.zero;
			holdBtn.Rect.anchorMax = Vector2.zero;
			holdBtn.Rect.pivot = Vector2.zero;
			holdBtn.Rect.anchoredPosition = new Vector2(14f, 12f);
			holdBtn.Go.SetActive(false);
		}

		private static void PositionUi()
		{
			//IL_013a: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: 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_0219: 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_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			if (!LoadingOverlay.TryGetLocalCardSlot(out var x, out var width, out var cardBottom))
			{
				if (playBtn.Go.activeSelf)
				{
					playBtn.Go.SetActive(false);
				}
				raceBtn.Go.SetActive(false);
				wormsBtn.Go.SetActive(false);
				tankBtn.Go.SetActive(false);
				colorsBtn.Go.SetActive(false);
				if ((Object)(object)strip != (Object)null)
				{
					strip.SetActive(false);
				}
				return;
			}
			if (!playBtn.Go.activeSelf)
			{
				playBtn.Go.SetActive(true);
				raceBtn.Go.SetActive(true);
				wormsBtn.Go.SetActive(true);
				tankBtn.Go.SetActive(true);
				colorsBtn.Go.SetActive(true);
				if ((Object)(object)strip != (Object)null)
				{
					strip.SetActive(true);
				}
			}
			float num = Mathf.Min(110f, (width - 22f) / 5f);
			float num2 = num + 4f;
			float num3 = cardBottom - 22f;
			playBtn.Rect.sizeDelta = new Vector2(num, 30f);
			raceBtn.Rect.sizeDelta = new Vector2(num, 30f);
			wormsBtn.Rect.sizeDelta = new Vector2(num, 30f);
			tankBtn.Rect.sizeDelta = new Vector2(num, 30f);
			colorsBtn.Rect.sizeDelta = new Vector2(num, 30f);
			playBtn.Rect.anchoredPosition = new Vector2(x - 2f * num2, num3);
			raceBtn.Rect.anchoredPosition = new Vector2(x - 1f * num2, num3);
			wormsBtn.Rect.anchoredPosition = new Vector2(x, num3);
			tankBtn.Rect.anchoredPosition = new Vector2(x + 1f * num2, num3);
			colorsBtn.Rect.anchoredPosition = new Vector2(x + 2f * num2, num3);
			bool interactable = NetworkUser.readOnlyInstancesList.Count <= 1 || NetworkServer.active;
			wormsBtn.Interactable = interactable;
			raceBtn.Interactable = interactable;
			if ((Object)(object)stripRect != (Object)null)
			{
				float x2 = stripRect.sizeDelta.x;
				float num4 = (LoadingOverlay.MultiRowWall ? (LoadingOverlay.WallBottom - 44f) : (cardBottom - 44f));
				num4 = Mathf.Max(num4, -408f + stripH);
				Rect rect = ((RectTransform)root.transform).rect;
				float num5 = ((Rect)(ref rect)).width * 0.5f;
				if (num5 < 1f)
				{
					num5 = 960f;
				}
				float num6 = Mathf.Max(num5 - 10f - x2 * 0.5f, 0f);
				float num7 = Mathf.Clamp(x, 0f - num6, num6);
				stripRect.anchoredPosition = new Vector2(num7, num4 - stripH * 0.5f);
			}
		}

		private static float StripWidthFor(GameKind kind, float cardW)
		{
			switch (kind)
			{
			case GameKind.Worms:
				return 1100f;
			case GameKind.Race:
				return 1100f;
			case GameKind.Terrarium:
				if (NetworkUser.readOnlyInstancesList.Count > 1 && !LoadingOverlay.MultiRowWall)
				{
					return cardW;
				}
				return 700f;
			default:
				if (NetworkUser.readOnlyInstancesList.Count > 1 && !LoadingOverlay.MultiRowWall)
				{
					return cardW;
				}
				return 480f;
			}
		}

		internal static float RunnerFieldWidthFor(float cardW)
		{
			return StripWidthFor(GameKind.Runner, (cardW <= 0f) ? 480f : cardW) - 4f;
		}

		private static void ResetGameButtons()
		{
			playBtn.Text = "RUNNER";
			raceBtn.Text = "RACE";
			wormsBtn.Text = "WORMS";
			tankBtn.Text = "TANK";
			btnNoteUntil = 0f;
			btnNoteOn = null;
			btnNotePrior = null;
		}

		private static void FlashButtonNote(UiKit.Btn btn, string note)
		{
			if (btnNoteOn != btn)
			{
				if (btnNoteOn != null && btnNotePrior != null)
				{
					btnNoteOn.Text = btnNotePrior;
				}
				btnNotePrior = btn.Text;
			}
			btn.Text = note;
			btnNoteOn = btn;
			btnNoteUntil = Time.unscaledTime + 2.5f;
		}

		private static void TickButtonNote()
		{
			if (!(btnNoteUntil <= 0f) && !(Time.unscaledTime < btnNoteUntil))
			{
				btnNoteUntil = 0f;
				if (btnNoteOn != null && btnNotePrior != null)
				{
					btnNoteOn.Text = btnNotePrior;
				}
				btnNoteOn = null;
				btnNotePrior = null;
			}
		}

		private static void StartOrStop(GameKind kind)
		{
			if ((game is WormsGame { MatchId: not 0u } || game is RaceGame { MatchId: not 0u }) && !NetworkServer.active)
			{
				return;
			}
			if (kind == GameKind.Worms && NetworkUser.readOnlyInstancesList.Count > 1)
			{
				if (NetworkServer.active && (!(game is WormsGame wormsGame2) || !StopHostedMatch(wormsGame2.MatchId)))
				{
					StartWormsMultiplayer();
				}
				return;
			}
			if (kind == GameKind.Race && NetworkUser.readOnlyInstancesList.Count > 1)
			{
				if (NetworkServer.active && (!(game is RaceGame raceGame2) || !StopHostedMatch(raceGame2.MatchId)))
				{
					StartRaceMultiplayer();
				}
				return;
			}
			bool flag = game != null && activeKind == kind;
			if (game != null)
			{
				EndGame();
				ResetGameButtons();
				LoadingOverlay.InvalidateCards();
				if (flag)
				{
					return;
				}
			}
			StartGame(kind, null, null);
		}

		private static void StartGame(GameKind kind, WormsGame.MatchConfig matchCfg, RaceGame.MatchConfig raceCfg)
		{
			//IL_008e: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			if (game != null)
			{
				EndGame();
			}
			ResetGameButtons();
			activeKind = kind;
			lastKind = kind;
			stripH = kind switch
			{
				GameKind.Terrarium => 185f, 
				GameKind.Race => 208f, 
				GameKind.Worms => 185f, 
				_ => 150f, 
			};
			LoadingOverlay.TryGetLocalCardSlot(out var _, out var width, out var _);
			float num = StripWidthFor(kind, (width <= 0f) ? 480f : width);
			UiWindow uiWindow = new UiWindow("arcadeStrip", root.transform, new Color(0.03f, 0.035f, 0.05f, 0.97f), UiKit.Outline);
			strip = uiWindow.Go;
			stripRect = uiWindow.Rect;
			stripRect.sizeDelta = new Vector2(num, stripH);
			LoadingOverlay.InvalidateCards();
			stripContent = uiWindow.AddMaskedContent();
			ArcadeContext ctx = new ArcadeContext
			{
				seed = VoxelTerrainManager.StageSeed,
				panel = stripContent,
				width = num - 4f,
				height = stripH - 4f,
				wormsMatch = matchCfg,
				raceMatch = raceCfg
			};
			IMiniGame miniGame2;
			switch (kind)
			{
			default:
			{
				IMiniGame miniGame = new RunnerGame();
				miniGame2 = miniGame;
				break;
			}
			case GameKind.Terrarium:
			{
				IMiniGame miniGame = new TerrariumGame();
				miniGame2 = miniGame;
				break;
			}
			case GameKind.Race:
			{
				IMiniGame miniGame = new RaceGame();
				miniGame2 = miniGame;
				break;
			}
			case GameKind.Worms:
			{
				IMiniGame miniGame = new WormsGame();
				miniGame2 = miniGame;
				break;
			}
			}
			game = miniGame2;
			game.Start(ctx);
			(kind switch
			{
				GameKind.Terrarium => tankBtn, 
				GameKind.Race => raceBtn, 
				GameKind.Worms => wormsBtn, 
				_ => playBtn, 
			}).Text = ((matchCfg != null || raceCfg != null) ? "MATCH ON" : "STOP");
		}

		private static void EndGame()
		{
			if (game != null)
			{
				if (game is WormsGame { MatchId: not 0u } || game is RaceGame { MatchId: not 0u })
				{
					lastKind = GameKind.Runner;
				}
				try
				{
					game.End();
				}
				catch (Exception ex)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] arcade game teardown: " + ex.Message));
				}
				game = null;
			}
			if ((Object)(object)strip != (Object)null)
			{
				Object.Destroy((Object)(object)strip);
				strip = null;
				stripRect = null;
				stripContent = null;
			}
		}

		private static void FoldLocalMatch()
		{
			EndGame();
			ResetGameButtons();
			LoadingOverlay.InvalidateCards();
		}

		private static void DropMatchChannels()
		{
			wormsChannel = null;
			raceChannel = null;
		}

		private static void TickMatchChannels()
		{
			wormsChannel?.Tick();
			raceChannel?.Tick();
		}

		private static bool StopHostedMatch(uint runningMatchId)
		{
			if (runningMatchId == 0)
			{
				return false;
			}
			if (Time.unscaledTime - matchStartedAt >= 0.75f)
			{
				EndGame();
				ResetGameButtons();
				LoadingOverlay.InvalidateCards();
			}
			return true;
		}

		private static uint[] DraftModdedPlayers(string gameName, UiKit.Btn button)
		{
			//IL_0024: 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)
			List<uint> list = new List<uint>();
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if (!((Object)(object)readOnlyInstances == (Object)null))
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					uint value = ((NetworkInstanceId)(ref netId)).Value;
					if ((((NetworkBehaviour)readOnlyInstances).isLocalPlayer || VoxelTerrainManager.IsModdedUser(value)) && !list.Contains(value))
					{
						list.Add(value);
					}
					if (list.Count == 8)
					{
						break;
					}
				}
			}
			if (list.Count < 2)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] " + gameName + ": no other modded players to draft"));
				FlashButtonNote(button, "WAITING FOR PLAYERS");
				return null;
			}
			matchStartedAt = Time.unscaledTime;
			return list.ToArray();
		}

		private static uint NewMatchId()
		{
			return (uint)((Environment.TickCount * -1640531535) | 1);
		}

		private static byte[] ResolveColorways(uint[] ids)
		{
			int num = ids.Length;
			int[] array = new int[num];
			bool[] array2 = new bool[16];
			for (int i = 0; i < num; i++)
			{
				array[i] = -1;
			}
			int[] array3 = new int[num];
			for (int j = 0; j < num; j++)
			{
				array3[j] = j;
			}
			Array.Sort(array3, (int a, int b) => ids[a].CompareTo(ids[b]));
			int[] array4;
			for (int num2 = 0; num2 < 3; num2++)
			{
				array4 = array3;
				foreach (int num4 in array4)
				{
					if (array[num4] < 0)
					{
						RosterEntry rosterEntry = LoadingRoster.Find(ids[num4]);
						int num5 = ((rosterEntry == null) ? (-1) : (num2 switch
						{
							1 => rosterEntry.prefB, 
							0 => rosterEntry.prefA, 
							_ => rosterEntry.prefC, 
						}));
						if (num5 >= 0 && num5 < array2.Length && !array2[num5])
						{
							array[num4] = num5;
							array2[num5] = true;
						}
					}
				}
			}
			array4 = array3;
			foreach (int num6 in array4)
			{
				if (array[num6] < 0)
				{
					int num7 = CommandoSprites.ColorwayFor(ids[num6]);
					while (array2[num7])
					{
						num7 = (num7 + 1) % array2.Length;
					}
					array[num6] = num7;
					array2[num7] = true;
				}
			}
			byte[] array5 = new byte[num];
			for (int num8 = 0; num8 < num; num8++)
			{
				array5[num8] = (byte)array[num8];
			}
			return array5;
		}

		private static void StartWormsMultiplayer()
		{
			uint[] array = DraftModdedPlayers("worms", wormsBtn);
			if (array != null)
			{
				uint num = NewMatchId();
				uint seed = VoxelTerrainManager.StageSeed ^ num;
				Random random = new Random((int)seed);
				for (int num2 = array.Length - 1; num2 > 0; num2--)
				{
					int num3 = random.Next(num2 + 1);
					ref uint reference = ref array[num2];
					ref uint reference2 = ref array[num3];
					uint num4 = array[num3];
					uint num5 = array[num2];
					reference = num4;
					reference2 = num5;
				}
				WormsGame.MatchConfig matchConfig = new WormsGame.MatchConfig
				{
					matchId = num,
					seed = seed,
					ids = array,
					colorways = ResolveColorways(array)
				};
				wormsChannel = WormsChannel.Host(matchConfig);
				StartGame(GameKind.Worms, matchConfig, null);
			}
		}

		internal static void HostApplyWormsShot(WormsShot shot)
		{
			wormsChannel?.HostApplyShot(shot);
		}

		internal static void OnWormsShotRequest(uint matchId, WormsShot shot)
		{
			if (wormsChannel != null && wormsChannel.OwnsMatch(matchId))
			{
				wormsChannel.HostApplyClientRequest(shot);
			}
		}

		internal static void OnWormsShot(uint matchId, int index, WormsShot shot)
		{
			if (game is WormsGame wormsGame && wormsGame.MatchId == matchId && index == wormsGame.KnownShotCount)
			{
				wormsGame.QueueCanonShot(shot);
			}
		}

		internal static void OnWormsMatchMessage(uint matchId, uint seed, uint[] ids, byte[] colorways, WormsShot[] shots)
		{
			if ((Object)(object)root == (Object)null || !ModOptions.ArcadeEnabled.Value)
			{
				return;
			}
			if (matchId == 0 || ids.Length == 0)
			{
				if (game is WormsGame { MatchId: not 0u })
				{
					FoldLocalMatch();
				}
				wormsChannel = null;
			}
			else if (game is WormsGame wormsGame2 && wormsGame2.MatchId == matchId)
			{
				wormsChannel?.StampHostMsg();
				wormsGame2.CatchUp(shots);
			}
			else
			{
				wormsChannel = WormsChannel.Join(new WormsGame.MatchConfig
				{
					matchId = matchId,
					seed = seed,
					ids = ids,
					colorways = colorways
				}, shots);
			}
		}

		private static void StartRaceMultiplayer()
		{
			uint[] array = DraftModdedPlayers("race", raceBtn);
			if (array != null)
			{
				uint num = NewMatchId();
				RaceGame.MatchConfig matchConfig = new RaceGame.MatchConfig
				{
					matchId = num,
					seed = (VoxelTerrainManager.StageSeed ^ num),
					ids = array,
					colorways = ResolveColorways(array),
					round = 0,
					wins = new byte[array.Length]
				};
				raceChannel = RaceChannel.Host(matchConfig);
				StartGame(GameKind.Race, null, matchConfig);
			}
		}

		internal static void OnRaceMatchMessage(uint matchId, uint seed, byte round, uint[] ids, byte[] colorways, byte[] wins)
		{
			if ((Object)(object)root == (Object)null || !ModOptions.ArcadeEnabled.Value)
			{
				return;
			}
			if (matchId == 0 || ids.Length == 0)
			{
				if (game is RaceGame { MatchId: not 0u })
				{
					FoldLocalMatch();
				}
				raceChannel = null;
			}
			else if (game is RaceGame raceGame2 && raceGame2.MatchId == matchId)
			{
				raceChannel?.StampHostMsg();
				raceGame2.ApplyMatchState(round, wins);
			}
			else
			{
				raceChannel = RaceChannel.Join(new RaceGame.MatchConfig
				{
					matchId = matchId,
					seed = seed,
					ids = ids,
					colorways = colorways,
					round = round,
					wins = wins
				});
			}
		}
	}
	internal class ArcadeSnapshotMessage : INetMessage, ISerializableObject
	{
		public const int MaxObstacles = 8;

		private uint ownerNetId;

		private byte colorway;

		private ushort score;

		private byte state;

		private byte playerY;

		private byte speed;

		private byte[] obKind = new byte[8];

		private byte[] obX = new byte[8];

		private int obCount;

		public void Set(uint ownerNetId, byte colorway, ushort score, byte state, byte playerY, byte speed, byte[] obKind, byte[] obX, int obCount)
		{
			this.ownerNetId = ownerNetId;
			this.colorway = colorway;
			this.score = score;
			this.state = state;
			this.playerY = playerY;
			this.speed = speed;
			this.obKind = obKind;
			this.obX = obX;
			this.obCount = obCount;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(ownerNetId);
			writer.Write(colorway);
			writer.Write(score);
			writer.Write(state);
			writer.Write(playerY);
			writer.Write(speed);
			int num = Mathf.Min(obCount, 8);
			writer.Write((byte)num);
			for (int i = 0; i < num; i++)
			{
				writer.Write(obKind[i]);
				writer.Write(obX[i]);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			ownerNetId = reader.ReadPackedUInt32();
			colorway = reader.ReadByte();
			score = reader.ReadUInt16();
			state = reader.ReadByte();
			playerY = reader.ReadByte();
			speed = reader.ReadByte();
			int num = reader.ReadByte();
			if (obKind.Length < 8)
			{
				obKind = new byte[8];
				obX = new byte[8];
			}
			obCount = 0;
			for (int i = 0; i < num; i++)
			{
				byte b = reader.ReadByte();
				byte b2 = reader.ReadByte();
				if (obCount < 8)
				{
					obKind[obCount] = b;
					obX[obCount] = b2;
					obCount++;
				}
			}
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				if (!HostRelay.Relaying)
				{
					ArcadeSpectate.Store(ownerNetId, colorway, score, state, playerY, speed, obKind, obX, obCount);
					HostRelay.FanOut((INetMessage)(object)this, ownerNetId);
				}
			}
			else
			{
				ArcadeSpectate.Store(ownerNetId, colorway, score, state, playerY, speed, obKind, obX, obCount);
			}
		}
	}
	internal static class HostRelay
	{
		private static bool relaying;

		public static bool Relaying => relaying;

		public static void FanOut(INetMessage msg, uint ownerNetId)
		{
			if (ArcadeSpectate.IsLocalPlayer(ownerNetId))
			{
				return;
			}
			relaying = true;
			try
			{
				NetMessageExtensions.Send(msg, (NetworkDestination)1);
			}
			finally
			{
				relaying = false;
			}
		}
	}
	internal struct WormsShot
	{
		public const byte WeaponPass = byte.MaxValue;

		public const byte WeaponForfeit = 254;

		public uint shooterNetId;

		public byte weapon;

		public byte angle;

		public byte power;

		public ushort tx;

		public ushort ty;

		public void Write(NetworkWriter w)
		{
			w.WritePackedUInt32(shooterNetId);
			w.Write(weapon);
			w.Write(angle);
			w.Write(power);
			w.Write(tx);
			w.Write(ty);
		}

		public static WormsShot Read(NetworkReader r)
		{
			return new WormsShot
			{
				shooterNetId = r.ReadPackedUInt32(),
				weapon = r.ReadByte(),
				angle = r.ReadByte(),
				power = r.ReadByte(),
				tx = r.ReadUInt16(),
				ty = r.ReadUInt16()
			};
		}
	}
	internal class WormsMatchMessage : INetMessage, ISerializableObject
	{
		private uint matchId;

		private uint seed;

		private uint[] ids = Array.Empty<uint>();

		private byte[] colorways = Array.Empty<byte>();

		private WormsShot[] shots = Array.Empty<WormsShot>();

		public WormsMatchMessage()
		{
		}

		public WormsMatchMessage(uint matchId, uint seed, uint[] ids, byte[] colorways, WormsShot[] shots)
		{
			this.matchId = matchId;
			this.seed = seed;
			this.ids = ids;
			this.colorways = colorways;
			this.shots = shots;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(matchId);
			writer.WritePackedUInt32(seed);
			writer.Write((byte)ids.Length);
			for (int i = 0; i < ids.Length; i++)
			{
				writer.WritePackedUInt32(ids[i]);
				writer.Write(colorways[i]);
			}
			writer.Write((ushort)shots.Length);
			WormsShot[] array = shots;
			foreach (WormsShot wormsShot in array)
			{
				wormsShot.Write(writer);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			matchId = reader.ReadPackedUInt32();
			seed = reader.ReadPackedUInt32();
			int num = reader.ReadByte();
			ids = new uint[num];
			colorways = new byte[num];
			for (int i = 0; i < num; i++)
			{
				ids[i] = reader.ReadPackedUInt32();
				colorways[i] = reader.ReadByte();
			}
			int num2 = reader.ReadUInt16();
			shots = new WormsShot[num2];
			for (int j = 0; j < num2; j++)
			{
				shots[j] = WormsShot.Read(reader);
			}
		}

		public void OnReceived()
		{
			if (!NetworkServer.active)
			{
				ArcadeHost.OnWormsMatchMessage(matchId, seed, ids, colorways, shots);
			}
		}
	}
	internal class WormsShotRequestMessage : INetMessage, ISerializableObject
	{
		private uint matchId;

		private WormsShot shot;

		public WormsShotRequestMessage()
		{
		}

		public WormsShotRequestMessage(uint matchId, WormsShot shot)
		{
			this.matchId = matchId;
			this.shot = shot;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(matchId);
			shot.Write(writer);
		}

		public void Deserialize(NetworkReader reader)
		{
			matchId = reader.ReadPackedUInt32();
			shot = WormsShot.Read(reader);
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				ArcadeHost.OnWormsShotRequest(matchId, shot);
			}
		}
	}
	internal class WormsShotMessage : INetMessage, ISerializableObject
	{
		private uint matchId;

		private ushort index;

		private WormsShot shot;

		public WormsShotMessage()
		{
		}

		public WormsShotMessage(uint matchId, ushort index, WormsShot shot)
		{
			this.matchId = matchId;
			this.index = index;
			this.shot = shot;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(matchId);
			writer.Write(index);
			shot.Write(writer);
		}

		public void Deserialize(NetworkReader reader)
		{
			matchId = reader.ReadPackedUInt32();
			index = reader.ReadUInt16();
			shot = WormsShot.Read(reader);
		}

		public void OnReceived()
		{
			if (!NetworkServer.active)
			{
				ArcadeHost.OnWormsShot(matchId, index, shot);
			}
		}
	}
	internal class RaceMatchMessage : INetMessage, ISerializableObject
	{
		private uint matchId;

		private uint seed;

		private byte round;

		private uint[] ids = Array.Empty<uint>();

		private byte[] colorways = Array.Empty<byte>();

		private byte[] wins = Array.Empty<byte>();

		public RaceMatchMessage()
		{
		}

		public RaceMatchMessage(uint matchId, uint seed, byte round, uint[] ids, byte[] colorways, byte[] wins)
		{
			this.matchId = matchId;
			this.seed = seed;
			this.round = round;
			this.ids = ids;
			this.colorways = colorways;
			this.wins = wins;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(matchId);
			writer.WritePackedUInt32(seed);
			writer.Write(round);
			writer.Write((byte)ids.Length);
			for (int i = 0; i < ids.Length; i++)
			{
				writer.WritePackedUInt32(ids[i]);
				writer.Write(colorways[i]);
				writer.Write(wins[i]);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			matchId = reader.ReadPackedUInt32();
			seed = reader.ReadPackedUInt32();
			round = reader.ReadByte();
			int num = reader.ReadByte();
			ids = new uint[num];
			colorways = new byte[num];
			wins = new byte[num];
			for (int i = 0; i < num; i++)
			{
				ids[i] = reader.ReadPackedUInt32();
				colorways[i] = reader.ReadByte();
				wins[i] = reader.ReadByte();
			}
		}

		public void OnReceived()
		{
			if (!NetworkServer.active)
			{
				ArcadeHost.OnRaceMatchMessage(matchId, seed, round, ids, colorways, wins);
			}
		}
	}
	internal class RaceSnapshotMessage : INetMessage, ISerializableObject
	{
		private uint ownerNetId;

		private uint matchId;

		private byte round;

		private byte colorway;

		private byte state;

		private ushort sQ;

		private byte h;

		private byte speedQ;

		private byte laps;

		private ushort anchorQ;

		public void Set(uint ownerNetId, uint matchId, byte round, byte colorway, byte state, ushort sQ, byte h, byte speedQ, byte laps, ushort anchorQ)
		{
			this.ownerNetId = ownerNetId;
			this.matchId = matchId;
			this.round = round;
			this.colorway = colorway;
			this.state = state;
			this.sQ = sQ;
			this.h = h;
			this.speedQ = speedQ;
			this.laps = laps;
			this.anchorQ = anchorQ;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(ownerNetId);
			writer.WritePackedUInt32(matchId);
			writer.Write(round);
			writer.Write(colorway);
			writer.Write(state);
			writer.Write(sQ);
			writer.Write(h);
			writer.Write(speedQ);
			writer.Write(laps);
			writer.Write(anchorQ);
		}

		public void Deserialize(NetworkReader reader)
		{
			ownerNetId = reader.ReadPackedUInt32();
			matchId = reader.ReadPackedUInt32();
			round = reader.ReadByte();
			colorway = reader.ReadByte();
			state = reader.ReadByte();
			sQ = reader.ReadUInt16();
			h = reader.ReadByte();
			speedQ = reader.ReadByte();
			laps = reader.ReadByte();
			anchorQ = reader.ReadUInt16();
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				if (!HostRelay.Relaying)
				{
					RaceSpectate.Store(ownerNetId, matchId, round, colorway, state, sQ, h, speedQ, laps, anchorQ);
					HostRelay.FanOut((INetMessage)(object)this, ownerNetId);
				}
			}
			else
			{
				RaceSpectate.Store(ownerNetId, matchId, round, colorway, state, sQ, h, speedQ, laps, anchorQ);
			}
		}
	}
	internal static class RaceSpectate
	{
		internal class Snapshot
		{
			public byte round;

			public byte colorway;

			public bool dead;

			public bool roping;

			public bool racing;

			public float s;

			public float h;

			public float speedPxS;

			public int laps;

			public float anchorX;

			public float receivedAt;
		}

		public static readonly Dictionary<uint, Snapshot> Latest = new Dictionary<uint, Snapshot>();

		public static uint ActiveMatchId;

		public static void Store(uint ownerNetId, uint matchId, byte round, byte colorway, byte state, ushort sQ, byte h, byte speedQ, byte laps, ushort anchorQ)
		{
			if (matchId != 0 && matchId == ActiveMatchId && !ArcadeSpectate.IsLocalPlayer(ownerNetId))
			{
				if (!Latest.TryGetValue(ownerNetId, out var value))
				{
					value = (Latest[ownerNetId] = new Snapshot());
				}
				value.round = round;
				value.colorway = colorway;
				value.dead = (state & 1) != 0;
				value.roping = (state & 2) != 0;
				value.racing = (state & 4) != 0;
				value.s = (float)(int)sQ * 2f;
				value.h = (int)h;
				value.speedPxS = (float)(int)speedQ * 3f;
				value.laps = laps;
				value.anchorX = (float)(int)anchorQ * 2f;
				value.receivedAt = Time.unscaledTime;
			}
		}

		public static void Clear()
		{
			Latest.Clear();
		}
	}
	internal static class ArcadeSpectate
	{
		internal class Snapshot
		{
			public byte colorway;

			public ushort score;

			public bool ducking;

			public bool gameOver;

			public byte playerY;

			public float speedPxS;

			public readonly List<(byte kind, byte x)> obstacles = new List<(byte, byte)>();

			public float receivedAt;
		}

		public static readonly Dictionary<uint, Snapshot> Latest = new Dictionary<uint, Snapshot>();

		public const float StaleSeconds = 1.2f;

		public static bool IsLocalPlayer(uint netId)
		{
			//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)
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					NetworkInstanceId netId2 = ((NetworkBehaviour)readOnlyInstances).netId;
					if (((NetworkInstanceId)(ref netId2)).Value == netId)
					{
						return true;
					}
				}
			}
			return false;
		}

		public static void Store(uint ownerNetId, byte colorway, ushort score, byte state, byte playerY, byte speed, byte[] obKind, byte[] obX, int obCount)
		{
			if (!IsLocalPlayer(ownerNetId))
			{
				if (!Latest.TryGetValue(ownerNetId, out var value))
				{
					value = (Latest[ownerNetId] = new Snapshot());
				}
				value.colorway = colorway;
				value.score = score;
				value.ducking = (state & 1) != 0;
				value.gameOver = (state & 2) != 0;
				value.playerY = playerY;
				value.speedPxS = (float)(int)speed * 2f;
				value.obstacles.Clear();
				int num = Mathf.Min(obCount, 8);
				for (int i = 0; i < num; i++)
				{
					value.obstacles.Add((obKind[i], obX[i]));
				}
				value.receivedAt = Time.unscaledTime;
			}
		}

		public static void Clear()
		{
			Latest.Clear();
		}
	}
	internal static class ArcadeThemes
	{
		public struct Theme
		{
			public string name;

			public Color32 deep;

			public Color32 mid;

			public Color32 slab;

			public Color32 stal;

			public Color32 cap;

			public byte dress;
		}

		public const byte DressCaps = 1;

		public const byte DressMotes = 2;

		public const byte DressStrata = 4;

		public const byte DressGlow = 8;

		public static readonly Theme[] All = new Theme[12]
		{
			new Theme
			{
				name = "PLAINS",
				deep = new Color32((byte)44, (byte)40, (byte)32, byte.MaxValue),
				mid = new Color32((byte)82, (byte)70, (byte)48, byte.MaxValue),
				slab = new Color32((byte)118, (byte)98, (byte)64, byte.MaxValue),
				stal = new Color32((byte)64, (byte)54, (byte)40, byte.MaxValue),
				cap = new Color32((byte)98, (byte)148, (byte)70, byte.MaxValue),
				dress = 1
			},
			new Theme
			{
				name = "ROOST",
				deep = new Color32((byte)34, (byte)36, (byte)46, byte.MaxValue),
				mid = new Color32((byte)62, (byte)66, (byte)82, byte.MaxValue),
				slab = new Color32((byte)94, (byte)100, (byte)118, byte.MaxValue),
				stal = new Color32((byte)50, (byte)54, (byte)66, byte.MaxValue),
				cap = new Color32((byte)172, (byte)178, (byte)190, byte.MaxValue),
				dress = 5
			},
			new Theme
			{
				name = "AQUEDUCT",
				deep = new Color32((byte)52, (byte)38, (byte)26, byte.MaxValue),
				mid = new Color32((byte)98, (byte)70, (byte)42, byte.MaxValue),
				slab = new Color32((byte)136, (byte)100, (byte)58, byte.MaxValue),
				stal = new Color32((byte)76, (byte)54, (byte)34, byte.MaxValue),
				cap = new Color32((byte)192, (byte)160, (byte)104, byte.MaxValue),
				dress = 5
			},
			new Theme
			{
				name = "DELTA",
				deep = new Color32((byte)30, (byte)38, (byte)48, byte.MaxValue),
				mid = new Color32((byte)58, (byte)74, (byte)90, byte.MaxValue),
				slab = new Color32((byte)92, (byte)112, (byte)130, byte.MaxValue),
				stal = new Color32((byte)46, (byte)58, (byte)70, byte.MaxValue),
				cap = new Color32((byte)218, (byte)228, (byte)238, byte.MaxValue),
				dress = 3
			},
			new Theme
			{
				name = "ACRES",
				deep = new Color32((byte)30, (byte)26, (byte)24, byte.MaxValue),
				mid = new Color32((byte)56, (byte)46, (byte)40, byte.MaxValue),
				slab = new Color32((byte)82, (byte)66, (byte)54, byte.MaxValue),
				stal = new Color32((byte)44, (byte)36, (byte)32, byte.MaxValue),
				cap = new Color32((byte)214, (byte)118, (byte)44, byte.MaxValue),
				dress = 8
			},
			new Theme
			{
				name = "GROVE",
				deep = new Color32((byte)40, (byte)28, (byte)30, byte.MaxValue),
				mid = new Color32((byte)74, (byte)48, (byte)52, byte.MaxValue),
				slab = new Color32((byte)106, (byte)68, (byte)70, byte.MaxValue),
				stal = new Color32((byte)56, (byte)38, (byte)40, byte.MaxValue),
				cap = new Color32((byte)170, (byte)86, (byte)96, byte.MaxValue),
				dress = 9
			},
			new Theme
			{
				name = "SIREN",
				deep = new Color32((byte)34, (byte)40, (byte)40, byte.MaxValue),
				mid = new Color32((byte)70, (byte)78, (byte)74, byte.MaxValue),
				slab = new Color32((byte)104, (byte)112, (byte)104, byte.MaxValue),
				stal = new Color32((byte)52, (byte)60, (byte)56, byte.MaxValue),
				cap = new Color32((byte)160, (byte)98, (byte)58, byte.MaxValue),
				dress = 12
			},
			new Theme
			{
				name = "MEADOW",
				deep = new Color32((byte)36, (byte)32, (byte)52, byte.MaxValue),
				mid = new Color32((byte)66, (byte)58, (byte)94, byte.MaxValue),
				slab = new Color32((byte)96, (byte)86, (byte)130, byte.MaxValue),
				stal = new Color32((byte)50, (byte)44, (byte)72, byte.MaxValue),
				cap = new Color32((byte)152, (byte)134, (byte)202, byte.MaxValue),
				dress = 2
			},
			new Theme
			{
				name = "FOREST",
				deep = new Color32((byte)26, (byte)34, (byte)32, byte.MaxValue),
				mid = new Color32((byte)50, (byte)66, (byte)58, byte.MaxValue),
				slab = new Color32((byte)76, (byte)96, (byte)84, byte.MaxValue),
				stal = new Color32((byte)38, (byte)50, (byte)44, byte.MaxValue),
				cap = new Color32((byte)208, (byte)220, (byte)224, byte.MaxValue),
				dress = 3
			},
			new Theme
			{
				name = "MOON",
				deep = new Color32((byte)40, (byte)40, (byte)44, byte.MaxValue),
				mid = new Color32((byte)76, (byte)76, (byte)82, byte.MaxValue),
				slab = new Color32((byte)110, (byte)110, (byte)118, byte.MaxValue),
				stal = new Color32((byte)58, (byte)58, (byte)64, byte.MaxValue),
				cap = new Color32((byte)202, (byte)202, (byte)212, byte.MaxValue),
				dress = 4
			},
			new Theme
			{
				name = "VOID",
				deep = new Color32((byte)28, (byte)22, (byte)40, byte.MaxValue),
				mid = new Color32((byte)54, (byte)42, (byte)76, byte.MaxValue),
				slab = new Color32((byte)82, (byte)62, (byte)110, byte.MaxValue),
				stal = new Color32((byte)42, (byte)32, (byte)58, byte.MaxValue),
				cap = new Color32((byte)198, (byte)90, (byte)152, byte.MaxValue),
				dress = 2
			},
			new Theme
			{
				name = "SULFUR",
				deep = new Color32((byte)44, (byte)40, (byte)26, byte.MaxValue),
				mid = new Color32((byte)82, (byte)74, (byte)42, byte.MaxValue),
				slab = new Color32((byte)116, (byte)104, (byte)58, byte.MaxValue),
				stal = new Color32((byte)62, (byte)56, (byte)32, byte.MaxValue),
				cap = new Color32((byte)182, (byte)192, (byte)72, byte.MaxValue),
				dress = 9
			}
		};

		public static Theme RollTheme(ref uint rngState, string destinationScene)
		{
			Theme result = All[ArcadeRng.Next(ref rngState, All.Length)];
			int num = ForScene(destinationScene);
			if (num < 0)
			{
				return result;
			}
			return All[num];
		}

		public static int ForScene(string scene)
		{
			if (string.IsNullOrEmpty(scene))
			{
				return -1;
			}
			int num = Lookup(scene);
			if (num < 0 && scene.Length > 2 && scene[0] == 'i' && scene[1] == 't')
			{
				num = Lookup(scene.Substring(2));
			}
			return num;
			static int Lookup(string s)
			{
				switch (s)
				{
				case "habitatfall":
				case "golemplains":
				case "golemplains2":
				case "lakes":
				case "lakesnight":
				case "habitat":
					return 0;
				case "blackbeach2":
				case "blackbeach":
					return 1;
				case "villagenight":
				case "goolake":
				case "village":
					return 2;
				case "ancientloft":
				case "frozenwall":
					return 3;
				case "wispgraveyard":
				case "artifactworld":
				case "lemuriantemple":
					return 4;
				case "rootjungle":
				case "helminthroost":
				case "dampcavesimple":
					return 5;
				case "shipgraveyard":
					return 6;
				case "skymeadow":
					return 7;
				case "snowyforest":
				case "foggyswamp":
					return 8;
				case "moon2":
				case "moon":
					return 9;
				case "arena":
				case "voidstage":
				case "voidraid":
					return 10;
				case "sulfurpools":
				case "goldshores":
					return 11;
				default:
					return -1;
				}
			}
		}

		public static Color32 Scale(Color32 c, float f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			return new Color32((byte)Mathf.Clamp((float)(int)c.r * f, 0f, 255f), (byte)Mathf.Clamp((float)(int)c.g * f, 0f, 255f), (byte)Mathf.Clamp((float)(int)c.b * f, 0f, 255f), byte.MaxValue);
		}

		public static uint DressHash(int x, int y)
		{
			int num = x * 374761393 + y * 668265263;
			int num2 = (num ^ (num >>> 13)) * 1274126177;
			return (uint)(num2 ^ (num2 >>> 16));
		}

		public static bool StrataBand(int x, int y, int groupShift, int salt, bool drift, int period, int thickness)
		{
			return (y + (int)(DressHash(x >> groupShift, salt) % 5) + (drift ? (x >> 3) : 0)) % period < thickness;
		}

		public static bool AccentSeed(int x, int y, int rarity)
		{
			return DressHash(x, y) % (uint)rarity == 0;
		}
	}
	internal static class CommandoSprites
	{
		public enum Critter
		{
			Lemurian,
			Golem,
			Child,
			Drone
		}

		private class Anim
		{
			public Sprite[] frames;

			public float[] frameEnds;

			public Vector2 size;

			public int IndexAt(float t)
			{
				float num = frameEnds[frameEnds.Length - 1];
				if (num <= 0f)
				{
					return 0;
				}
				float num2 = t % num;
				for (int i = 0; i < frameEnds.Length; i++)
				{
					if (num2 < frameEnds[i])
					{
						return i;
					}
				}
				return frames.Length - 1;
			}

			public Sprite At(float t)
			{
				return frames[IndexAt(t)];
			}
		}

		private const string Dir = "RoR2/Base/loadingbasic/";

		private static readonly string[] CritterKeys = new string[4] { "RoR2/Base/loadingbasic/ssaLemurianWalk.asset", "RoR2/Base/loadingbasic/ssaGolem.asset", "RoR2/Base/loadingbasic/ssaChildWalk.asset", "RoR2/Base/loadingbasic/ssaDroneHover.asset" };

		private static readonly Color32[] RampSrc = (Color32[])(object)new Color32[4]
		{
			new Color32((byte)131, (byte)69, (byte)39, byte.MaxValue),
			new Color32((byte)193, (byte)128, (byte)62, byte.MaxValue),
			new Color32((byte)223, (byte)183, (byte)98, byte.MaxValue),
			new Color32((byte)244, (byte)243, (byte)183, byte.MaxValue)
		};

		private static readonly float[] RampDrift = new float[4] { 0f, 10f, 21f, 39f };

		private static readonly float[] RampSat = new float[4] { 0.7f, 0.68f, 0.56f, 0.25f };

		private static readonly float[] RampVal = new float[4] { 0.51f, 0.76f, 0.87f, 0.96f };

		private const float BaseHue = 20f;

		private static readonly float[] Hues = new float[16]
		{
			20f,
			355f,
			48f,
			85f,
			125f,
			165f,
			190f,
			210f,
			235f,
			262f,
			285f,
			315f,
			335f,
			float.NaN,
			float.NaN,
			float.NaN
		};

		private const int PastelIndex = 12;

		private static readonly float[][] NeutralVals = new float[3][]
		{
			new float[4] { 0.62f, 0.78f, 0.9f, 0.98f },
			new float[4] { 0.38f, 0.52f, 0.62f, 0.72f },
			new float[4] { 0.16f, 0.24f, 0.3f, 0.38f }
		};

		public const int ColorwayCount = 16;

		public static readonly string[] ColorwayNames = new string[16]
		{
			"Orange", "Red", "Yellow", "Lime", "Green", "Teal", "Cyan", "Azure", "Blue", "Indigo",
			"Purple", "Magenta", "Pink", "White", "Grey", "Black"
		};

		private static bool loadStarted;

		private static Anim[] commando;

		private static bool[][] commandoMasks;

		private static readonly Anim[] critters = new Anim[4];

		private static readonly List<Texture2D> ownedTextures = new List<Texture2D>();

		private static int pendingLoads;

		public static bool Ready { get; private set; }

		public static bool Failed { get; private set; }

		public static Vector2 CommandoSize => commando[0].size;

		public static void EnsureLoading()
		{
			if (loadStarted)
			{
				return;
			}
			loadStarted = true;
			pendingLoads = 1 + CritterKeys.Length;
			LoadSsa("RoR2/Base/loadingbasic/ssaCommandoWalk.asset", delegate(SimpleSpriteAnimation anim)
			{
				try
				{
					BuildCommandoColorways(anim);
				}
				catch (Exception ex)
				{
					Failed = true;
					ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] commando recolor failed, arcade disabled: " + ex.Message));
				}
			});
			for (int num = 0; num < CritterKeys.Length; num++)
			{
				int idx = num;
				LoadSsa(CritterKeys[idx], delegate(SimpleSpriteAnimation anim)
				{
					critters[idx] = FromSsa(anim);
				});
			}
		}

		private static void LoadSsa(string key, Action<SimpleSpriteAnimation> onLoaded)
		{
			//IL_001a: 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)
			try
			{
				AsyncOperationHandle<SimpleSpriteAnimation> val = Addressables.LoadAssetAsync<SimpleSpriteAnimation>((object)key);
				val.Completed += delegate(AsyncOperationHandle<SimpleSpriteAnimation> op)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Invalid comparison between Unknown and I4
					if ((int)op.Status == 1 && (Object)(object)op.Result != (Object)null && op.Result.frames != null && op.Result.frames.Length != 0)
					{
						onLoaded(op.Result);
					}
					else
					{
						Failed = true;
						ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] arcade sprite load failed (" + key + ") — arcade disabled"));
					}
					if (--pendingLoads == 0 && !Failed)
					{
						Ready = true;
					}
				};
			}
			catch (Exception ex)
			{
				Failed = true;
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] arcade sprite load threw (" + key + "): " + ex.Message));
			}
		}

		private static Anim FromSsa(SimpleSpriteAnimation ssa)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			int num = ssa.frames.Length;
			Anim anim = new Anim
			{
				frames = (Sprite[])(object)new Sprite[num],
				frameEnds = new float[num]
			};
			float num2 = ((ssa.frameRate > 0f) ? ssa.frameRate : 60f);
			for (int i = 0; i < num; i++)
			{
				anim.frames[i] = ssa.frames[i].sprite;
				anim.frameEnds[i] = (float)ssa.frames[i].duration / num2;
			}
			for (int j = 1; j < num; j++)
			{
				if (anim.frameEnds[j] <= anim.frameEnds[j - 1])
				{
					anim.frameEnds[j] = anim.frameEnds[j - 1] + 1f / num2;
				}
			}
			Rect rect = anim.frames[0].rect;
			anim.size = new Vector2(((Rect)(ref rect)).width, ((Rect)(ref rect)).height);
			return anim;
		}

		private static void BuildCommandoColorways(SimpleSpriteAnimation ssa)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_0098: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: 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_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			Texture2D texture = ssa.frames[0].sprite.texture;
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)texture).width, ((Texture)texture).height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)2);
			RenderTexture active = RenderTexture.active;
			Graphics.Blit((Texture)(object)texture, temporary);
			RenderTexture.active = temporary;
			Texture2D val = new Texture2D(((Texture)texture).width, ((Texture)texture).height, (TextureFormat)4, false);
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), 0, 0, false);
			val.Apply(false, false);
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
			Color32[] pixels = val.GetPixels32();
			Object.Destroy((Object)val);
			commandoMasks = new bool[ssa.frames.Length][];
			for (int i = 0; i < ssa.frames.Length; i++)
			{
				Rect rect = ssa.frames[i].sprite.rect;
				int num = (int)((Rect)(ref rect)).x;
				int num2 = (int)((Rect)(ref rect)).y;
				int num3 = (int)((Rect)(ref rect)).width;
				int num4 = (int)((Rect)(ref rect)).height;
				bool[] array = new bool[num3 * num4];
				for (int j = 0; j < num4; j++)
				{
					for (int k = 0; k < num3; k++)
					{
						array[j * num3 + k] = pixels[(num2 + j) * ((Texture)texture).width + num + k].a > 40;
					}
				}
				commandoMasks[i] = array;
			}
			commando = new Anim[16];
			Color32[] array2 = (Color32[])(object)new Color32[pixels.Length];
			Color32[] array3 = (Color32[])(object)new Color32[RampSrc.Length];
			for (int l = 0; l < 16; l++)
			{
				for (int m = 0; m < RampSrc.Length; m++)
				{
					array3[m] = ColorwayColor(l, m);
				}
				for (int n = 0; n < pixels.Length; n++)
				{
					Color32 val2 = pixels[n];
					if (val2.a == 0)
					{
						array2[n] = val2;
						continue;
					}
					int num5 = MatchRamp(val2);
					array2[n] = (Color32)((num5 >= 0) ? new Color32(array3[num5].r, array3[num5].g, array3[num5].b, val2.a) : val2);
				}
				Texture2D val3 = new Texture2D(((Texture)texture).width, ((Texture)texture).height, (TextureFormat)4, false)
				{
					filterMode = (FilterMode)0,
					wrapMode = (TextureWrapMode)1
				};
				val3.SetPixels32(array2);
				val3.Apply(false, true);
				ownedTextures.Add(val3);
				Anim anim = new Anim
				{
					frames = (Sprite[])(object)new Sprite[ssa.frames.Length],
					frameEnds = new float[ssa.frames.Length]
				};
				float num6 = ((ssa.frameRate > 0f) ? ssa.frameRate : 60f);
				for (int num7 = 0; num7 < ssa.frames.Length; num7++)
				{
					Rect rect2 = ssa.frames[num7].sprite.rect;
					anim.frames[num7] = Sprite.Create(val3, rect2, new Vector2(0.5f, 0f), 100f);
					anim.frameEnds[num7] = (float)ssa.frames[num7].duration / num6;
				}
				for (int num8 = 1; num8 < anim.frameEnds.Length; num8++)
				{
					if (anim.frameEnds[num8] <= anim.frameEnds[num8 - 1])
					{
						anim.frameEnds[num8] = anim.frameEnds[num8 - 1] + 1f / num6;
					}
				}
				Rect rect3 = anim.frames[0].rect;
				anim.size = new Vector2(((Rect)(ref rect3)).width, ((Rect)(ref rect3)).height);
				commando[l] = anim;
			}
		}

		private static int MatchRamp(Color32 p)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0016: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < RampSrc.Length; i++)
			{
				Color32 val = RampSrc[i];
				if (Mathf.Abs(p.r - val.r) <= 8 && Mathf.Abs(p.g - val.g) <= 8 && Mathf.Abs(p.b - val.b) <= 8)
				{
					return i;
				}
			}
			return -1;
		}

		private static Color32 ColorwayColor(int colorway, int step)
		{
			//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_0086: 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_009e: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			float num = Hues[colorway];
			Color val;
			if (float.IsNaN(num))
			{
				val = Color.HSVToRGB(0f, 0f, NeutralVals[colorway - 13][step]);
			}
			else
			{
				float num2 = RampSat[step];
				float num3 = RampVal[step];
				if (colorway == 12)
				{
					num2 *= 0.55f;
					num3 = Mathf.Min(1f, num3 + 0.22f * (1f - num3) + 0.1f);
				}
				val = Color.HSVToRGB(Mathf.Repeat(num + RampDrift[step], 360f) / 360f, num2, num3);
			}
			return new Color32((byte)Mathf.RoundToInt(val.r * 255f), (byte)Mathf.RoundToInt(val.g * 255f), (byte)Mathf.RoundToInt(val.b * 255f), byte.MaxValue);
		}

		public static Sprite CommandoFrame(int colorway, float t)
		{
			return commando[Mod16(colorway)].At(t);
		}

		public static bool CommandoOpaque(float t, int px, int py)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 size = commando[0].size;
			int num = (int)size.x;
			int num2 = (int)size.y;
			if (px < 0 || px >= num || py < 0 || py >= num2)
			{
				return false;
			}
			return commandoMasks[commando[0].IndexAt(t)][py * num + px];
		}

		public static Color Tint(int colorway)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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)
			//IL_0027: 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)
			Color32 val = ColorwayColor(Mod16(colorway), 1);
			return new Color((float)(int)val.r / 255f, (float)(int)val.g / 255f, (float)(int)val.b / 255f, 1f);
		}

		public static Sprite CritterFrame(Critter c, float t)
		{
			return critters[(int)c].At(t);
		}

		public static Vector2 CritterSize(Critter c)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return critters[(int)c].size;
		}

		private static int Mod16(int i)
		{
			return (i % 16 + 16) % 16;
		}

		public static int ColorwayFor(uint userNetId)
		{
			return (int)(userNetId % 16);
		}
	}
	internal static class DecorStamps
	{
		public const int Count = 25;

		public const int W = 40;

		public const int H = 44;

		private static int DRng(ref uint st, int max)
		{
			return ArcadeRng.Next(ref st, max);
		}

		public static int Raster(int id, byte[] cv, ref uint st)
		{
			Array.Clear(cv, 0, cv.Length);
			int num = 12;
			int num2 = 12;
			switch (id)
			{
			case 0:
			{
				int num23 = 4 + DRng(ref st, 4);
				Disc(num23, num23 - 1, num23, 1);
				Disc(num23 - 1, num23, num23 - 3, 2);
				num = 2 * num23 + 1;
				num2 = 2 * num23;
				break;
			}
			case 1:
			{
				int num12 = 3 + DRng(ref st, 3);
				Disc(num12, num12 - 1, num12, 1);
				Disc(2 * num12 + 2, num12 - 2, num12 - 1, 1);
				Px(num12 - 1, 2 * num12 - 2, 2);
				num = 3 * num12 + 2;
				num2 = 2 * num12;
				break;
			}
			case 2:
			{
				int num5 = 8 + DRng(ref st, 7);
				int num6 = 2 + DRng(ref st, 2);
				TriUp(num6, 0, num6, num5, 1);
				Px(num6, num5 - 1, 2);
				num = 2 * num6 + 1;
				num2 = num5;
				break;
			}
			case 3:
			{
				int num34 = 7 + DRng(ref st, 6);
				TriUp(3, 0, 3, num34, 1);
				TriUp(9, 0, 3, num34 - 3 + DRng(ref st, 3), 1);
				TriUp(14, 0, 2, num34 - 4, 1);
				num = 17;
				num2 = num34;
				break;
			}
			case 4:
			{
				int num28 = 16 + DRng(ref st, 9);
				TriUp(3, 0, 3, num28, 1);
				Px(3, num28 - 1, 2);
				Px(2, num28 - 4, 2);
				num = 7;
				num2 = num28;
				break;
			}
			case 5:
			{
				int num10 = 4 + DRng(ref st, 2);
				int num11 = 0;
				for (int l = 0; l < 3 + DRng(ref st, 2); l++)
				{
					if (num10 <= 1)
					{
						break;
					}
					Disc(6, num11 + num10 - 1, num10, 1);
					Px(6, num11 + 2 * num10 - 2, 2);
					num11 += 2 * num10 - 2;
					num10--;
				}
				num = 13;
				num2 = num11 + 4;
				break;
			}
			case 6:
			{
				int num29 = 9 + DRng(ref st, 5);
				for (int num30 = 0; num30 < num29; num30++)
				{
					Rect(2 + num30 / 3, num30, 4, 1, 1);
				}
				Rect(2 + (num29 - 1) / 3, num29 - 1, 4, 1, 2);
				num = 7 + num29 / 3;
				num2 = num29;
				break;
			}
			case 7:
			{
				for (int num22 = 0; num22 < 7 + DRng(ref st, 4); num22++)
				{
					Rect(DRng(ref st, 16), DRng(ref st, 3), 1 + DRng(ref st, 2), 1 + DRng(ref st, 2), (byte)(1 + DRng(ref st, 2)));
				}
				num = 18;
				num2 = 5;
				break;
			}
			case 8:
			{
				int num19 = 8 + DRng(ref st, 5);
				Rect(1, 0, 4, num19, 1);
				Px(2, num19 - 1, 2);
				Px(3, num19 / 2, 3);
				num = 6;
				num2 = num19;
				break;
			}
			case 9:
			{
				int num18 = 9 + DRng(ref st, 4);
				Rect(1, 0, 2, num18, 1);
				Rect(10, 0, 2, num18, 1);
				Rect(0, num18, 13, 2, 1);
				Px(1, num18 - 1, 2);
				Px(11, num18 - 1, 2);
				num = 13;
				num2 = num18 + 2;
				break;
			}
			case 10:
			{
				int num14 = 5 + DRng(ref st, 4);
				Rect(1, 0, 3, num14, 1);
				Rect(1, num14, 3, 1, 2);
				Disc(8, 1, 2, 1);
				num = 11;
				num2 = num14 + 1;
				break;
			}
			case 11:
				Rect(0, 0, 14 + DRng(ref st, 5), 2, 1);
				Rect(2, 2, 10, 2, 1);
				Rect(4, 4, 6, 2, 2);
				num = 19;
				num2 = 6;
				break;
			case 12:
			{
				for (int j = 0; j < 5 + DRng(ref st, 3); j++)
				{
					Rect(j * 2 + DRng(ref st, 2), 0, 1, 2 + DRng(ref st, 3), 3);
				}
				num = 14;
				num2 = 5;
				break;
			}
			case 13:
			{
				for (int num31 = 0; num31 < 2 + DRng(ref st, 2); num31++)
				{
					int num32 = num31 * 5 + 2;
					int num33 = 2 + DRng(ref st, 2);
					Rect(num32, 0, 1, num33, 2);
					Disc(num32, num33 + 1, 2, 3);
				}
				num = 14;
				num2 = 7;
				break;
			}
			case 14:
				Rect(0, 0, 12, 1, 2);
				TriUp(3, 1, 2, 6 + DRng(ref st, 3), 3);
				TriUp(7, 1, 2, 4 + DRng(ref st, 3), 3);
				TriUp(10, 1, 1, 5, 3);
				num = 13;
				num2 = 11;
				break;
			case 15:
			{
				int num25 = 4 + DRng(ref st, 2);
				for (int num26 = 0; num26 < num25; num26++)
				{
					int num27 = 6 - Mathf.Abs(num26 - num25 / 2);
					Rect(num26 * 3, 0, 1, num27, 2);
					Px(num26 * 3 + 1, num27 - 1, 2);
				}
				num = num25 * 3;
				num2 = 7;
				break;
			}
			case 16:
			{
				int num24 = 8 + DRng(ref st, 6);
				TriDown(3, num24 - 1, 3, num24, 1);
				TriDown(9, num24 - 1, 3, num24 - 3, 1);
				TriDown(14, num24 - 1, 2, num24 - 5, 1);
				num = 17;
				num2 = num24;
				break;
			}
			case 17:
			{
				int num20 = 5 + DRng(ref st, 4);
				for (int num21 = 0; num21 < num20; num21++)
				{
					TriDown(num21 * 3 + 1, 5, 1, 3 + DRng(ref st, 3), 2);
				}
				num = num20 * 3;
				num2 = 6;
				break;
			}
			case 18:
			{
				int num15 = 10 + DRng(ref st, 7);
				for (int n = 0; n < 3; n++)
				{
					int num16 = n * 4 + 1;
					for (int num17 = 0; num17 < num15 - n * 2; num17++)
					{
						Px(num16 + ((num17 / 3) & 1), num15 - 1 - num17, 2);
					}
					Px(num16, num15 - 1 - (num15 - n * 2) + 1, 3);
				}
				num = 11;
				num2 = num15;
				break;
			}
			case 19:
			{
				int num13 = 8 + DRng(ref st, 4);
				for (int m = 0; m < num13; m++)
				{
					Px(6 - m / 2, num13 - 1 - m, 2);
					Px(7 + m / 3, num13 - 1 - m, 2);
					if (m > 3)
					{
						Px(10 + m / 3, num13 - 1 - m, 2);
					}
				}
				num = 15;
				num2 = num13;
				break;
			}
			case 20:
				TriDown(3, 7, 2, 6 + DRng(ref st, 2), 3);
				TriDown(8, 7, 2, 4, 3);
				TriDown(12, 7, 1, 5, 3);
				Rect(0, 7, 14, 1, 2);
				num = 14;
				num2 = 8;
				break;
			case 21:
			{
				int num9 = 8 + DRng(ref st, 7);
				for (int k = 0; k < num9; k++)
				{
					if ((k & 1) == 0)
					{
						Rect(k, k / 2, 2, 1, 3);
					}
				}
				num = num9 + 2;
				num2 = num9 / 2 + 1;
				break;
			}
			case 22:
			{
				int num8 = 4 + DRng(ref st, 3);
				Disc(num8, num8, num8, 1);
				Ring(num8, num8, num8 - 2, 3);
				num = 2 * num8 + 1;
				num2 = 2 * num8 + 1;
				break;
			}
			case 23:
			{
				int num7 = 4 + DRng(ref st, 2);
				Ring(num7, num7, num7, 2);
				Ring(num7, num7, num7 - 2, 2);
				Px(num7, num7, 2);
				num = 2 * num7 + 1;
				num2 = 2 * num7 + 1;
				break;
			}
			default:
			{
				int num3 = 12 + DRng(ref st, 7);
				for (int i = 0; i < num3; i++)
				{
					int num4 = Mathf.Max(1, 3 - Mathf.Abs(i - num3 / 2) * 6 / num3);
					Rect(i, 2 - num4 / 2, 1, num4, 1);
				}
				num = num3;
				num2 = 5;
				break;
			}
			}
			return (Mathf.Min(num, 40) << 8) | Mathf.Min(num2, 44);
			void Disc(int cx, int cy, int r, byte s)
			{
				for (int num35 = -r; num35 <= r; num35++)
				{
					for (int num36 = -r; num36 <= r; num36++)
					{
						if (num35 * num35 + num36 * num36 <= r * r)
						{
							Px(cx + num35, cy + num36, s);
						}
					}
				}
			}
			void Px(int x, int y, byte s)
			{
				if (x >= 0 && y >= 0 && x < 40 && y < 44)
				{
					cv[y * 40 + x] = s;
				}
			}
			void Rect(int x, int y, int rw, int rh, byte s)
			{
				for (int num35 = 0; num35 < rw; num35++)
				{
					for (int num36 = 0; num36 < rh; num36++)
					{
						Px(x + num35, y + num36, s);
					}
				}
			}
			void Ring(int cx, int cy, int r, byte s)
			{
				for (int num35 = -r; num35 <= r; num35++)
				{
					for (int num36 = -r; num36 <= r; num36++)
					{
						int num37 = num35 * num35 + num36 * num36;
						if (num37 <= r * r && num37 > (r - 1) * (r - 1))
						{
							Px(cx + num35, cy + num36, s);
						}
					}
				}
			}
			void TriDown(int cx, int topY, int halfW, int ht, byte s)
			{
				for (int num35 = 0; num35 < ht; num35++)
				{
					int num36 = Mathf.Max(halfW * (ht - num35) / ht, 0);
					for (int num37 = -num36; num37 <= num36; num37++)
					{
						Px(cx + num37, topY - num35, s);
					}
				}
			}
			void TriUp(int cx, int baseY, int halfW, int ht, byte s)
			{
				for (int num35 = 0; num35 < ht; num35++)
				{
					int num36 = Mathf.Max(halfW * (ht - num35) / ht, 0);
					for (int num37 = -num36; num37 <= num36; num37++)
					{
						Px(cx + num37, baseY + num35, s);
					}
				}
			}
		}
	}
	internal static class PetSprite
	{
		public delegate void SetPx(int x, int y, byte r, byte g, byte b);

		public enum Shape
		{
			Classic,
			Round,
			Tall,
			Squat,
			Pear,
			Dome,
			Brick,
			Wedge
		}

		public enum Pattern
		{
			Solid,
			Speckled,
			Banded,
			Spotted,
			Patched,
			Gradient,
			Mottled
		}

		public enum EyeStyle
		{
			Classic,
			Warm,
			Jade,
			Sky,
			Sparkle,
			Odd
		}

		public enum Accessory
		{
			None,
			MossTuft,
			Mushroom,
			CrystalCrown,
			HornNubs,
			Antenna,
			BackSpikes,
			Sprout,
			Flower,
			TopHat,
			PartyCone,
			SnailShell,
			CatEars,
			BunnyEars,
			Halo,
			Bow,
			Pebblet,
			Feather,
			Twig,
			Antlers,
			Lichen,
			Barnacles,
			CrystalStud,
			Candle,
			Fin,
			TailNub,
			Scarf
		}

		public enum Aura
		{
			None,
			GlowRim,
			SparkleField,
			Drips,
			OrbitMote
		}

		public enum Foil
		{
			None,
			Prismatic,
			LiquidGold,
			Starfield,
			Ripple,
			VoidSkin,
			ChefFire
		}

		public struct Look
		{
			public byte bodyR;

			public byte bodyG;

			public byte bodyB;

			public byte bellyR;

			public byte bellyG;

			public byte bellyB;

			public byte speckR;

			public byte speckG;

			public byte speckB;

			public int eyeGap;

			public uint salt;

			public bool shiny;

			public int shinyCoat;

			public Shape shape;

			public Pattern pattern;

			public EyeStyle eyes;

			public Accessory accessory;

			public Aura aura;

			public bool blush;

			public Foil foil;
		}

		public const int Stages = 5;

		public static readonly int[] W = new int[5] { 5, 7, 10, 14, 18 };

		public static readonly int[] H = new int[5] { 4, 5, 8, 11, 12 };

		private static readonly byte[,] Body = new byte[5, 3]
		{
			{ 118, 120, 128 },
			{ 130, 118, 102 },
			{ 144, 120, 98 },
			{ 152, 112, 80 },
			{ 166, 98, 60 }
		};

		private static readonly byte[,] ShinyCoat = new byte[6, 3]
		{
			{ 96, 156, 118 },
			{ 176, 112, 130 },
			{ 182, 152, 76 },
			{ 118, 152, 176 },
			{ 142, 110, 172 },
			{ 106, 140, 94 }
		};

		private static readonly string[] ShinyNames = new string[6] { "JADE", "ROSE QUARTZ", "PYRITE", "GLACIER", "AMETHYST", "MOSS AGATE" };

		private static readonly int[] ShapeW8 = new int[8] { 26, 17, 13, 10, 10, 9, 8, 7 };

		private static readonly int[] PatternW8 = new int[7] { 24, 26, 15, 12, 9, 8, 6 };

		private static readonly int[] EyeW8 = new int[6] { 55, 15, 11, 9, 6, 4 };

		private static readonly byte[,] EyeCol = new byte[6, 3]
		{
			{ 245, 245, 250 },
			{ 255, 210, 140 },
			{ 150, 230, 170 },
			{ 150, 200, 250 },
			{ 250, 250, 255 },
			{ 245, 245, 250 }
		};

		private static readonly int[] AccessoryW8 = new int[27]
		{
			30, 5, 4, 2, 4, 3, 3, 4, 3, 2,
			2, 3, 3, 2, 1, 3, 3, 2, 2, 2,
			3, 2, 2, 2, 3, 3, 2
		};

		private static readonly int[] AuraW8 = new int[5] { 86, 5, 4, 3, 2 };

		private static readonly int[] FoilW8 = new int[7] { 90, 3, 2, 2, 1, 1, 1 };

		private const int CoverW = 30;

		private const int CoverH = 22;

		private static readonly bool[] coverFlag = new bool[660];

		private static readonly byte[] coverR = new byte[660];

		private static readonly byte[] coverG = new byte[660];

		private static readonly byte[] coverB = new byte[660];

		public static bool WantsShaderSkin(Foil f)
		{
			if (f != Foil.VoidSkin)
			{
				return f == Foil.ChefFire;
			}
			return true;
		}

		public static Look DeriveLook(uint seed, int stage)
		{
			stage = ((stage >= 0) ? ((stage >= 5) ? 4 : stage) : 0);
			uint s = seed | 1;
			Look result = new Look
			{
				shiny = IsShiny(seed)
			};
			int num = Body[stage, 0];
			int num2 = Body[stage, 1];
			int num3 = Body[stage, 2];
			if (result.shiny)
			{
				result.shinyCoat = (int)(Step0(seed ^ 0xC0A7) % 6);
				num = (ShinyCoat[result.shinyCoat, 0] * 2 + num) / 3;
				num2 = (ShinyCoat[result.shinyCoat, 1] * 2 + num2) / 3;
				num3 = (ShinyCoat[result.shinyCoat, 2] * 2 + num3) / 3;
			}
			result.bodyR = JitterC(num, ref s);
			result.bodyG = JitterC(num2, ref s);
			result.bodyB = JitterC(num3, ref s);
			result.bellyR = Lighten(result.bodyR);
			result.bellyG = Lighten(result.bodyG);
			result.bellyB = Lighten(result.bodyB);
			result.speckR = Darken(result.bodyR);
			result.speckG = Darken(result.bodyG);
			result.speckB = Darken(result.bodyB);
			result.eyeGap = (int)(1 + Step(ref s) % (uint)Max(1, W[stage] / 4));
			Step(ref s);
			result.salt = Step(ref s);
			result.shape = (Shape)WeightPick(ref s, ShapeW8);
			result.pattern = (Pattern)WeightPick(ref s, PatternW8);
			result.eyes = (EyeStyle)WeightPick(ref s, EyeW8);
			result.accessory = (Accessory)WeightPick(ref s, AccessoryW8);
			result.aura = (Aura)WeightPick(ref s, AuraW8);
			result.blush = Step(ref s) % 5 == 0;
			result.foil = (Foil)WeightPick(ref s, FoilW8);
			return result;
		}

		public static string Describe(uint seed, int stage)
		{
			Look look = DeriveLook(seed, stage);
			string text = (look.shiny ? ("SHINY " + ShinyNames[look.shinyCoat]) : look.shape.ToString().ToUpperInvariant());
			if (look.pattern != Pattern.Solid)
			{
				text = text + " · " + look.pattern.ToString().ToUpperInvariant();
			}
			if (look.eyes != EyeStyle.Classic)
			{
				text = text + " · " + look.eyes.ToString().ToUpperInvariant() + " EYES";
			}
			if (look.accessory != Accessory.None)
			{
				text = text + " · " + AccessoryName(look.accessory);
			}
			if (look.aura != Aura.None)
			{
				text = text + " · " + AuraName(look.aura);
			}
			if (look.blush)
			{
				text += " · BLUSH";
			}
			if (look.foil != Foil.None)
			{
				text = text + " · " + FoilName(look.foil) + " FOIL";
			}
			return text;
		}

		private static string FoilName(Foil f)
		{
			return f switch
			{
				Foil.Prismatic => "PRISMATIC", 
				Foil.LiquidGold => "LIQUID GOLD", 
				Foil.Starfield => "STARFIELD", 
				Foil.Ripple => "RIPPLE", 
				Foil.VoidSkin => "VOIDSKIN", 
				Foil.ChefFire => "CHEF'S FIRE", 
				_ => "", 
			};
		}

		private static string AccessoryName(Accessory a)
		{
			return a switch
			{
				Accessory.MossTuft => "MOSS TUFT", 
				Accessory.Mushroom => "MUSHROOM", 
				Accessory.CrystalCrown => "CRYSTAL CROWN", 
				Accessory.HornNubs => "HORN NUBS", 
				Accessory.Antenna => "ANTENNA", 
				Accessory.BackSpikes => "BACK SPIKES", 
				Accessory.Sprout => "SPROUT", 
				Accessory.Flower => "FLOWER", 
				Accessory.TopHat => "TOP HAT", 
				Accessory.PartyCone => "PARTY CONE", 
				Accessory.SnailShell => "SNAIL SHELL", 
				Accessory.CatEars => "CAT EARS", 
				Accessory.BunnyEars => "BUNNY EARS", 
				Accessory.Halo => "HALO", 
				Accessory.Bow => "BOW", 
				Accessory.Pebblet => "PEBBLET", 
				Accessory.Feather => "FEATHER", 
				Accessory.Twig => "TWIG", 
				Accessory.Antlers => "ANTLERS", 
				Accessory.Lichen => "LICHEN", 
				Accessory.Barnacles => "BARNACLES", 
				Accessory.CrystalStud => "CRYSTAL STUD", 
				Accessory.Candle => "CANDLE", 
				Accessory.Fin => "FIN", 
				Accessory.TailNub => "TAIL NUB", 
				Accessory.Scarf => "SCARF", 
				_ => "", 
			};
		}

		private static string AuraName(Aura a)
		{
			return a switch
			{
				Aura.GlowRim => "GLOW", 
				Aura.SparkleField => "SPARKLE", 
				Aura.Drips => "DRIPPY", 
				Aura.OrbitMote => "ORBITED", 
				_ => "", 
			};
		}

		public static void Paint(SetPx set, int originX, int originY, int stage, uint seed, bool sleeping, bool blink, bool wide, int facing, float squash, bool bulge, float t, SetPx setFine = null, bool hollowBody = false, Foil? foilOverride = null, bool inert = false, SetPx setSkin = null)
		{
			stage = ((stage >= 0) ? ((stage >= 5) ? 4 : stage) : 0);
			Look look = DeriveLook(seed, stage);
			if (foilOverride.HasValue)
			{
				look.foil = foilOverride.Value;
			}
			int num = W[stage] + (bulge ? 1 : 0);
			int num2 = H[stage];
			switch (look.shape)
			{
			case Shape.Round:
				num -= ((stage >= 2) ? 1 : 0);
				num2 += ((stage >= 2) ? 1 : 0);
				break;
			case Shape.Tall:
				num -= ((stage >= 1) ? 1 : 0);
				num2++;
				break;
			case Shape.Squat:
				num++;
				num2 -= ((stage >= 1) ? 1 : 0);
				break;
			case Shape.Pear:
				num2++;
				break;
			case Shape.Dome:
				num += ((stage >= 1) ? 1 : 0);
				break;
			case Shape.Brick:
				num += ((stage >= 1) ? 1 : 0);
				break;
			case Shape.Wedge:
				num2 += ((stage >= 2) ? 1 : 0);
				break;
			}
			if (sleeping)
			{
				num2 = ((num2 > 3) ? (num2 - 1) : num2);
			}
			int num3 = Max(3, RoundToInt((float)num2 * Clamp(squash, 0.6f, 1.35f)));
			int num4 = Max(num, RoundToInt((float)num * (2f - Clamp(squash, 0.7f, 1.3f))));
			int num5 = originX - num4 / 2;
			int num6 = ((look.shape == Shape.Round) ? Max(1, num4 / 5) : ((look.shape != Shape.Brick) ? ((stage < 3) ? 1 : 2) : 0));
			bool flag = setFine != null && look.foil != Foil.None && !inert && !hollowBody;
			if (flag)
			{
				Array.Clear(coverFlag, 0, coverFlag.Length);
			}
			for (int i = 0; i < num3; i++)
			{
				for (int j = 0; j < num4; j++)
				{
					bool flag2 = i >= num3 - 1;
					bool flag3 = i == 0;
					if (((flag2 || flag3) && (j < num6 || j >= num4 - num6)) || (look.shape == Shape.Round && (flag2 || flag3) && (j < num6 + 1 || j >= num4 - num6 - 1) && num4 > 6) || ShapeSkips(look.shape, j, i, num4, num3))
					{
						continue;
					}
					if (hollowBody && j > 0 && j < num4 - 1 && i > 0 && i < num3 - 1)
					{
						setSkin?.Invoke(num5 + j, originY + i, 0, 0, 0);
						continue;
					}
					byte r;
					byte g;
					byte b;
					if (flag3 && j > 0 && j < num4 - 1)
					{
						r = look.bellyR;
						g = look.bellyG;
						b = look.bellyB;
					}
					else
					{
						PatternColor(look, j, i, num4, num3, out r, out g, out b);
					}
					if (stage == 3 && i == num3 / 2 && j % 4 == 1)
					{
						r = (byte)(r * 3 / 4);
						g = (byte)(g * 3 / 4);
						b = (byte)(b * 3 / 4);
					}
					if (stage == 4 && (flag3 || Hash(j, i + (int)look.salt) % 13 == 0))
					{
						r = byte.MaxValue;
						g = 150;
						b = 64;
					}
					set(num5 + j, originY + i, r, g, b);
					if (flag && j < 30 && i < 22)
					{
						int num7 = i * 30 + j;
						coverFlag[num7] = true;
						coverR[num7] = r;
						coverG[num7] = g;
						coverB[num7] = b;
					}
				}
			}
			if (stage >= 2 && !sleeping)
			{
				for (int k = 0; k < stage - 1; k++)
				{
					int x = num5 + 1 + (int)(Hash((int)look.salt, k * 31) % (uint)Max(1, num4 - 2));
					int y = originY + num3 - 2 - (int)(Hash(k * 17, (int)look.salt) % 2);
					set(x, y, 235, 240, 250);
				}
			}
			if (stage >= 1 && !sleeping)
			{
				set(num5 + num4 / 4, originY - 1, look.speckR, look.speckG, look.speckB);
				set(num5 + num4 - 1 - num4 / 4, originY - 1, look.speckR, look.speckG, look.speckB);
			}
			DrawAccessory(set, look, num5, originY, num4, num3, stage);
			DrawFace(set, look, originX, originY, num4, num3, stage, sleeping, blink, wide, facing);
			if (!sleeping)
			{
				DrawAura(set, look, originX, originY, num4, num3, t);
			}
			if (flag)
			{
				DrawFoil(setFine, look, num5, originY, num4, num3, t);
			}
		}

		private static bool ShapeSkips(Shape shape, int dx, int dy, int w, int h)
		{
			int num = h - 1 - dy;
			switch (shape)
			{
			case Shape.Pear:
			{
				int num2 = Max(1, (h - 2) / 3);
				if (num >= num2)
				{
					return false;
				}
				int num3 = 1 + (num2 - 1 - num) + w / 6;
				if (dx >= num3)
				{
					return dx >= w - num3;
				}
				return true;
			}
			case Shape.Dome:
				switch (num)
				{
				case 0:
					if (dx >= w / 4 + 1)
					{
						return dx >= w - w / 4 - 1;
					}
					return true;
				case 1:
					if (h >= 6)
					{
						if (dx >= w / 8 + 1)
						{
							return dx >= w - w / 8 - 1;
						}
						return true;
					}
					break;
				}
				return false;
			case Shape.Wedge:
				switch (num)
				{
				case 0:
					return dx < w / 2;
				case 1:
					if (h >= 8)
					{
						return dx < w / 4;
					}
					break;
				}
				return false;
			default:
				return false;
			}
		}

		private static void DrawFoil(SetPx setFine, Look look, int x0, int y0, int w, int h, float t)
		{
			float num = ((float)x0 + (float)w * 0.5f) * 3f;
			float num2 = ((float)y0 + (float)h * 0.5f) * 3f;
			for (int i = 0; i < h && i < 22; i++)
			{
				for (int j = 0; j < w && j < 30; j++)
				{
					int num3 = i * 30 + j;
					if (!coverFlag[num3])
					{
						continue;
					}
					byte b = coverR[num3];
					byte b2 = coverG[num3];
					byte b3 = coverB[num3];
					for (int k = 0; k < 3; k++)
					{
						for (int l = 0; l < 3; l++)
						{
							int num4 = (x0 + j) * 3 + l;
							int num5 = (y0 + i) * 3 + k;
							switch (look.foil)
							{
							case Foil.Prismatic:
							{
								float num14 = (float)(num4 + num5) * 0.5f - t * 9f;
								if (Mod(num14, 14f) < 3f)
								{
									HueTint(b, b2, b3, Mod(num14 * 11f, 360f), 0.7f, out var r, out var g, out var b7);
									setFine(num4, num5, r, g, b7);
								}
								break;
							}
							case Foil.LiquidGold:
							{
								float num7 = Sin((float)num4 * 0.55f + t * 3.1f) + Sin((float)num5 * 0.8f - t * 2.3f) + Sin((float)(num4 + num5) * 0.3f + t * 1.7f);
								if (num7 > 1.35f)
								{
									byte b5 = (byte)Min(255, 190 + (int)(num7 * 40f));
									setFine(num4, num5, b5, (byte)(b5 * 84 / 100), (byte)(b5 * 40 / 100));
								}
								break;
							}
							case Foil.Starfield:
							{
								int num10 = (int)(t * 2.5f);
								uint num11 = Hash(num4 * 7 + num10, num5 * 13 - num10 / 2);
								if (num11 % 34 == 0)
								{
									byte b6 = (byte)(200 + num11 % 56);
									setFine(num4, num5, b6, b6, byte.MaxValue);
								}
								break;
							}
							case Foil.Ripple:
							{
								float num12 = (float)num4 - num;
								float num13 = (float)num5 - num2;
								if (Mod((float)Math.Sqrt(num12 * num12 + num13 * num13) - t * 10f, 11f) < 1.4f && ((num4 + num5) & 1) == 0)
								{
									setFine(num4, num5, (byte)((b + 170) / 2), (byte)((b2 + 230) / 2), (byte)((b3 + 240) / 2));
								}
								break;
							}
							case Foil.VoidSkin:
							{
								float num8 = (float)num4 - num;
								float num9 = (float)num5 - num2;
								if (Mod((float)Math.Sqrt(num8 * num8 + num9 * num9) + t * 8f, 9f) < 1.5f)
								{
									setFine(num4, num5, (byte)((b + 140) / 2), (byte)(b2 / 2), (byte)((b3 + 240) / 2));
								}
								break;
							}
							case Foil.ChefFire:
							{
								float num6 = Sin((float)num4 * 0.5f + t * 2.2f) + Sin(((float)num5 - t * 6f) * 0.7f);
								if (num6 > 1.1f)
								{
									byte b4 = (byte)Min(255, 200 + (int)(num6 * 35f));
									setFine(num4, num5, b4, (byte)(b4 * 55 / 100), (byte)(b4 * 18 / 100));
								}
								break;
							}
							}
						}
					}
				}
			}
		}

		private static void HueTint(byte br, byte bg, byte bb, float hue, float strength, out byte r, out byte g, out byte b)
		{
			HsvToRgb(hue, 0.85f, 1f, out var r2, out var g2, out var b2);
			r = (byte)((float)(int)br * (1f - strength) + (float)(int)r2 * strength);
			g = (byte)((float)(int)bg * (1f - strength) + (float)(int)g2 * strength);
			b = (byte)((float)(int)bb * (1f - strength) + (float)(int)b2 * strength);
		}

		private static void HsvToRgb(float h, float s, float v, out byte r, out byte g, out byte b)
		{
			h = Mod(h, 360f) / 60f;
			int num = (int)h;
			float num2 = h - (float)num;
			float num3 = v * (1f - s);
			float num4 = v * (1f - s * num2);
			float num5 = v * (1f - s * (1f - num2));
			float num6;
			float num7;
			float num8;
			switch (num)
			{
			case 0:
				num6 = v;
				num7 = num5;
				num8 = num3;
				break;
			case 1:
				num6 = num4;
				num7 = v;
				num8 = num3;
				break;
			case 2:
				num6 = num3;
				num7 = v;
				num8 = num5;
				break;
			case 3:
				num6 = num3;
				num7 = num4;
				num8 = v;
				break;
			case 4:
				num6 = num5;
				num7 = num3;
				num8 = v;
				break;
			default:
				num6 = v;
				num7 = num3;
				num8 = num4;
				break;
			}
			r = (byte)(num6 * 255f);
			g = (byte)(num7 * 255f);
			b = (byte)(num8 * 255f);
		}

		private static float Mod(float a, float m)
		{
			float num = a % m;
			if (!(num < 0f))
			{
				return num;
			}
			return num + m;
		}

		private static void PatternColor(Look look, int dx, int dy, int w, int h, out byte r, out byte g, out byte b)
		{
			r = look.bodyR;
			g = look.bodyG;
			b = look.bodyB;
			switch (look.pattern)
			{
			case Pattern.Speckled:
				if (Hash(dx + (int)(look.salt & 0xFFFF), dy + (int)(look.salt >> 16)) % 7 == 0)
				{
					r = look.speckR;
					g = look.speckG;
					b = look.speckB;
				}
				break;
			case Pattern.Banded:
				if ((dy + (int)(look.salt % 3)) % 3 == 0)
				{
					r = look.speckR;
					g = look.speckG;
					b = look.speckB;
				}
				break;
			case Pattern.Spotted:
			{
				for (int i = 0; i < 3; i++)
				{
					int num = (int)(1 + Hash((int)look.salt, i * 13) % (uint)Max(1, w - 3));
					int num2 = (int)(1 + Hash(i * 29, (int)look.salt) % (uint)Max(1, h - 3));
					if (dx >= num && dx <= num + 1 && dy >= num2 && dy <= num2 + 1)
					{
						r = look.speckR;
						g = look.speckG;
						b = look.speckB;
					}
				}
				break;
			}
			case Pattern.Patched:
				if (dy > h / 2 && dx > w / 3)
				{
					r = look.speckR;
					g = look.speckG;
					b = look.speckB;
				}
				break;
			case Pattern.Gradient:
			{
				int num3 = dy * 24 / Max(1, h - 1);
				r = (byte)Min(255, r + num3);
				g = (byte)Min(255, g + num3);
				b = (byte)Min(255, b + num3);
				break;
			}
			case Pattern.Mottled:
				if (Hash(dx / 2 + (int)look.salt, dy / 2) % 3 == 0)
				{
					r = look.speckR;
					g = look.speckG;
					b = look.speckB;
				}
				break;
			}
		}

		private static void DrawAccessory(SetPx set, Look look, int x0, int y0, int w, int h, int stage)
		{
			int num = y0 + h;
			int num2 = x0 + w / 2;
			switch (look.accessory)
			{
			case Accessory.MossTuft:
				set(num2 - 1, num, 74, 120, 62);
				set(num2, num, 96, 148, 76);
				set(num2, num + 1, 74, 120, 62);
				break;
			case Accessory.Mushroom:
				set(num2, num, 214, 206, 186);
				set(num2 - 1, num + 1, 196, 84, 74);
				set(num2, num + 1, 214, 100, 88);
				set(num2 + 1, num + 1, 196, 84, 74);
				break;
			case Accessory.CrystalCrown:
			{
				for (int num6 = 0; num6 < Min(3, 1 + stage); num6++)
				{
					int x1 = num2 + (num6 - 1) * 2;
					set(x1, num, 168, 214, 240);
					set(x1, num + 1, 214, 240, 252);
				}
				break;
			}
			case Accessory.HornNubs:
				set(x0 + 1, num, look.speckR, look.speckG, look.speckB);
				set(x0 + w - 2, num, look.speckR, look.speckG, look.speckB);
				break;
			case Accessory.Antenna:
				set(num2, num, look.speckR, look.speckG, look.speckB);
				set(num2, num + 1, look.speckR, look.speckG, look.speckB);
				set(num2, num + 2, 235, 220, 160);
				break;
			case Accessory.BackSpikes:
			{
				for (int j = 0; j < 3; j++)
				{
					int num3 = x0 + w / 4 + j * Max(2, w / 4);
					if (num3 < x0 + w - 1)
					{
						set(num3, num, look.speckR, look.speckG, look.speckB);
					}
				}
				break;
			}
			case Accessory.Sprout:
				set(num2, num, 74, 130, 66);
				set(num2 - 1, num + 1, 96, 170, 84);
				set(num2 + 1, num + 1, 96, 170, 84);
				break;
			case Accessory.Flower:
				set(num2, num + 1, 250, 220, 90);
				set(num2 - 1, num + 1, 240, 238, 232);
				set(num2 + 1, num + 1, 240, 238, 232);
				set(num2, num, 240, 238, 232);
				set(num2, num + 2, 240, 238, 232);
				break;
			case Accessory.TopHat:
			{
				for (int n = -1; n <= 1; n++)
				{
					set(num2 + n, num, 40, 38, 46);
				}
				set(num2 - 1, num + 1, 40, 38, 46);
				set(num2, num + 1, 52, 48, 58);
				set(num2 - 1, num + 2, 40, 38, 46);
				set(num2, num + 2, 52, 48, 58);
				break;
			}
			case Accessory.PartyCone:
				set(num2 - 1, num, 230, 84, 96);
				set(num2, num, 230, 84, 96);
				set(num2, num + 1, 92, 140, 230);
				set(num2, num + 2, 250, 220, 90);
				break;
			case Accessory.SnailShell:
				set(x0 + 1, num - 1, 152, 112, 70);
				set(x0 + 2, num - 1, 178, 138, 92);
				set(x0 + 1, num - 2, 178, 138, 92);
				set(x0 + 2, num - 2, 120, 86, 56);
				break;
			case Accessory.CatEars:
				set(x0 + 1, num, look.bodyR, look.bodyG, look.bodyB);
				set(x0 + 1, num + 1, look.speckR, look.speckG, look.speckB);
				set(x0 + w - 2, num, look.bodyR, look.bodyG, look.bodyB);
				set(x0 + w - 2, num + 1, look.speckR, look.speckG, look.speckB);
				break;
			case Accessory.BunnyEars:
			{
				int num5 = Max(1, w / 4);
				for (int m = 0; m < 3; m++)
				{
					byte r = (byte)((m == 2) ? 235 : look.bodyR);
					set(num2 - num5, num + m, r, (byte)((m == 2) ? 170 : look.bodyG), (byte)((m == 2) ? 180 : look.bodyB));
					set(num2 + num5, num + m, r, (byte)((m == 2) ? 170 : look.bodyG), (byte)((m == 2) ? 180 : look.bodyB));
				}
				break;
			}
			case Accessory.Halo:
			{
				for (int l = -1; l <= 1; l++)
				{
					set(num2 + l, num + 2, byte.MaxValue, 232, 140);
				}
				break;
			}
			case Accessory.Bow:
				set(num2 - 1, num, 235, 120, 152);
				set(num2 + 1, num, 235, 120, 152);
				set(num2, num, 198, 78, 112);
				break;
			case Accessory.Pebblet:
				set(num2 + 1, num, 138, 140, 150);
				set(num2 + 2, num, 122, 124, 134);
				set(num2 + 1, num + 1, 245, 245, 250);
				break;
			case Accessory.Feather:
				set(x0 + 2, num, 226, 116, 84);
				set(x0 + 1, num + 1, 240, 150, 110);
				set(x0, num + 2, 226, 116, 84);
				break;
			case Accessory.Twig:
				set(num2 - 2, num, 124, 92, 60);
				set(num2 - 2, num + 1, 124, 92, 60);
				set(num2 - 3, num + 1, 156, 122, 82);
				break;
			case Accessory.Antlers:
				set(x0 + 1, num, 156, 122, 82);
				set(x0 + 1, num + 1, 156, 122, 82);
				set(x0, num + 1, 186, 150, 104);
				set(x0 + w - 2, num, 156, 122, 82);
				set(x0 + w - 2, num + 1, 156, 122, 82);
				set(x0 + w - 1, num + 1, 186, 150, 104);
				break;
			case Accessory.Lichen:
				set(x0 + 1, num - 1, 152, 182, 122);
				set(x0 + 2, num - 1, 132, 162, 108);
				set(x0 + 1, num - 2, 132, 162, 108);
				break;
			case Accessory.Barnacles:
			{
				for (int k = 0; k < 3; k++)
				{
					int num4 = y0 + 1 + k * Max(1, (h - 2) / 3);
					if (num4 < num - 1)
					{
						set(x0 + w - 1, num4, 214, 208, 190);
					}
				}
				break;
			}
			case Accessory.CrystalStud:
				set(x0 + w - 2, num - 1, 170, 220, 245);
				set(x0 + w - 1, num - 1, 224, 244, 252);
				break;
			case Accessory.Candle:
				set(num2, num, 232, 226, 208);
				set(num2, num + 1, 232, 226, 208);
				set(num2, num + 2, byte.MaxValue, 198, 88);
				break;
			case Accessory.Fin:
				set(num2, num, look.speckR, look.speckG, look.speckB);
				set(num2, num + 1, look.speckR, look.speckG, look.speckB);
				set(num2 + 1, num, look.speckR, look.speckG, look.speckB);
				break;
			case Accessory.TailNub:
				set(x0 - 1, y0 + 1, look.bodyR, look.bodyG, look.bodyB);
				set(x0 - 1, y0, look.speckR, look.speckG, look.speckB);
				break;
			case Accessory.Scarf:
			{
				for (int i = 1; i < w - 1; i++)
				{
					set(x0 + i, y0 + 1, (byte)(((i & 1) == 0) ? 198 : 176), 64, 70);
				}
				set(x0 + w - 2, y0, 176, 58, 64);
				break;
			}
			}
		}

		private static void DrawFace(SetPx set, Look look, int originX, int y0, int w, int h, int stage, bool sleeping, bool blink, bool wide, int facing)
		{
			int num = y0 + h - 2 - ((stage >= 2) ? 2 : 0) + (wide ? 1 : 0);
			if (num < y0 + 1)
			{
				num = y0 + 1;
			}
			int num2 = originX + facing * Max(1, w / 5);
			int eyeGap = look.eyeGap;
			if (sleeping || blink)
			{
				byte r = (byte)(look.bodyR / 2);
				byte g = (byte)(look.bodyG / 2);
				byte b = (byte)(look.bodyB / 2);
				set(num2 - eyeGap, num, r, g, b);
				set(num2 + eyeGap, num, r, g, b);
				return;
			}
			int eyes = (int)look.eyes;
			byte b2 = EyeCol[eyes, 0];
			byte b3 = EyeCol[eyes, 1];
			byte b4 = EyeCol[eyes, 2];
			if (stage == 4 && look.eyes == EyeStyle.Classic)
			{
				b2 = byte.MaxValue;
				b3 = 214;
				b4 = 140;
			}
			byte r2 = b2;
			byte g2 = b3;
			byte b5 = b4;
			if (look.eyes == EyeStyle.Odd)
			{
				int num3 = (int)(1 + look.salt % 3);
				r2 = EyeCol[num3, 0];
				g2 = EyeCol[num3, 1];
				b5 = EyeCol[num3, 2];
			}
			int num4 = ((stage >= 2) ? 1 : 0);
			for (int i = 0; i <= num4; i++)
			{
				set(num2 - eyeGap, num - i, b2, b3, b4);
				set(num2 + eyeGap, num - i, r2, g2, b5);
			}
			if (wide && stage >= 2)
			{
				set(num2 - eyeGap, num + 1, b2, b3, b4);
				set(num2 + eyeGap, num + 1, r2, g2, b5);
			}
			if (look.eyes == EyeStyle.Sparkle)
			{
				set(num2 - eyeGap + 1, num + ((num4 <= 0) ? 1 : 0), byte.MaxValue, byte.MaxValue, byte.MaxValue);
				set(num2 + eyeGap + 1, num + ((num4 <= 0) ? 1 : 0), byte.MaxValue, byte.MaxValue, byte.MaxValue);
			}
			if (stage >= 1)
			{
				byte r3 = (byte)(look.bodyR / 2);
				byte g3 = (byte)(look.bodyG / 2);
				byte b6 = (byte)(look.bodyB / 2);
				set(num2, num - 1 - num4, r3, g3, b6);
				if (stage >= 3)
				{
					set(num2 + facing, num - 1 - num4, r3, g3, b6);
				}
			}
			if (look.blush)
			{
				byte r4 = (byte)Min(255, look.bodyR + 60);
				byte g4 = (byte)Max(0, look.bodyG - 10);
				byte b7 = (byte)Max(0, look.bodyB + 10);
				set(num2 - eyeGap - 2, num - num4, r4, g4, b7);
				set(num2 + eyeGap + 2, num - num4, r4, g4, b7);
			}
		}

		private static void DrawAura(SetPx set, Look look, int originX, int y0, int w, int h, float t)
		{
			int num = originX - w / 2;
			switch (look.aura)
			{
			case Aura.GlowRim:
			{
				float num3 = 0.5f + 0.5f * Sin(t * 1.6f);
				byte r = (byte)(200f + 55f * num3);
				byte g = (byte)(170f + 40f * num3);
				byte b = 90;
				for (int j = 1; j < w - 1; j += 2)
				{
					set(num + j, y0 + h, r, g, b);
				}
				break;
			}
			case Aura.SparkleField:
			{
				int num4 = (int)(t * 3f);
				for (int k = 0; k < 3; k++)
				{
					uint num5 = Hash(num4 * 7 + k * 131, (int)(look.salt + k));
					int x3 = num - 2 + (int)(num5 % (uint)(w + 4));
					int y2 = y0 + 1 + (int)((num5 >> 8) % (uint)(h + 3));
					if (((num5 >> 16) & 1) == 0)
					{
						set(x3, y2, 250, 250, 210);
					}
				}
				break;
			}
			case Aura.Drips:
			{
				for (int i = 0; i < 2; i++)
				{
					float num2 = (t * 0.6f + (float)i * 0.5f) % 1f;
					int x2 = num + 2 + i * Max(2, w - 5);
					set(x2, y0 - (int)(num2 * 4f), look.bellyR, look.bellyG, look.bellyB);
				}
				break;
			}
			case Aura.OrbitMote:
			{
				float a = t * 2.2f;
				int x = originX + (int)(Cos(a) * (float)(w / 2 + 2));
				int y1 = y0 + h / 2 + (int)(Sin(a) * (float)(h / 2 + 2));
				set(x, y1, byte.MaxValue, 236, 160);
				break;
			}
			}
		}

		public static float BlinkPeriod(uint seed)
		{
			uint s = seed | 1;
			Step(ref s);
			Step(ref s);
			Step(ref s);
			Step(ref s);
			return 3f + (float)(Step(ref s) % 300) / 100f;
		}

		public static bool IsShiny(uint seed)
		{
			return Step0(seed) % 16 == 0;
		}

		private static int WeightPick(ref uint s, int[] weights)
		{
			int num = (int)(Step(ref s) % 100);
			for (int i = 0; i < weights.Length; i++)
			{
				num -= weights[i];
				if (num < 0)
				{
					return i;
				}
			}
			return 0;
		}

		private static byte JitterC(int v, ref uint s)
		{
			int num = v + (int)(Step(ref s) % 41) - 20;
			return (byte)((num < 30) ? 30u : ((num > 235) ? 235u : ((uint)num)));
		}

		private static byte Lighten(byte v)
		{
			return (byte)Min(255, v * 5 / 4 + 8);
		}

		private static byte Darken(byte v)
		{
			return (byte)(v * 7 / 10);
		}

		private static uint Step(ref uint s)
		{
			s ^= s << 13;
			s ^= s >> 17;
			s ^= s << 5;
			return s;
		}

		private static uint Step0(uint s)
		{
			s |= 1;
			s ^= s << 13;
			s ^= s >> 17;
			s ^= s << 5;
			return s;
		}

		private static uint Hash(int x, int y)
		{
			int num = x * 374761393 + y * 668265263;
			int num2 = (num ^ (num >>> 13)) * 1274126177;
			return (uint)(num2 ^ (num2 >>> 16));
		}

		private static int Max(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		private static int Min(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		private static float Clamp(float v, float lo, float hi)
		{
			if (!(v < lo))
			{
				if (!(v > hi))
				{
					return v;
				}
				return hi;
			}
			return lo;
		}

		private static int RoundToInt(float v)
		{
			return (int)(v + 0.5f);
		}

		private static float Sin(float a)
		{
			return (float)Math.Sin(a);
		}

		private static float Cos(float a)
		{
			return (float)Math.Cos(a);
		}
	}
	internal class PixelSurface
	{
		public readonly int W;

		public readonly int H;

		public readonly RawImage Image;

		private readonly Color32[] px;

		private readonly Texture2D tex;

		private bool dirty;

		public PixelSurface(string name, Transform parent, int cellsW, int cellsH, float cellPx)
		{
			//IL_003c: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			W = cellsW;
			H = cellsH;
			px = (Color32[])(object)new Color32[W * H];
			tex = new Texture2D(W, H, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Image = val.AddComponent<RawImage>();
			Image.texture = (Texture)(object)tex;
			((Graphic)Image).raycastTarget = false;
			((Graphic)Image).rectTransform.sizeDelta = new Vector2((float)W * cellPx, (float)H * cellPx);
			Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			Flush();
		}

		public void Clear(Color32 c)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < px.Length; i++)
			{
				px[i] = c;
			}
			dirty = true;
		}

		public void Set(int x, int y, Color32 c)
		{
			//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)
			if (x >= 0 && y >= 0 && x < W && y < H)
			{
				px[y * W + x] = c;
				dirty = true;
			}
		}

		public Color32 Get(int x, int y)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (x < 0 || y < 0 || x >= W || y >= H)
			{
				return default(Color32);
			}
			return px[y * W + x];
		}

		public void FillRect(int x0, int y0, int w, int h, Color32 c)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Min(x0 + w, W);
			int num2 = Mathf.Min(y0 + h, H);
			x0 = Mathf.Max(x0, 0);
			y0 = Mathf.Max(y0, 0);
			for (int i = y0; i < num2; i++)
			{
				int num3 = i * W;
				for (int j = x0; j < num; j++)
				{
					px[num3 + j] = c;
				}
			}
			dirty = (num > x0 && num2 > y0) || dirty;
		}

		public void FillCircle(int cx, int cy, int r, Color32 c)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			int num = r * r;
			int num2 = Mathf.Max(cy - r, 0);
			int num3 = Mathf.Min(cy + r, H - 1);
			for (int i = num2; i <= num3; i++)
			{
				int num4 = i - cy;
				int num5 = (int)Mathf.Sqrt((float)(num - num4 * num4));
				int num6 = Mathf.Max(cx - num5, 0);
				int num7 = Mathf.Min(cx + num5, W - 1);
				int num8 = i * W;
				for (int j = num6; j <= num7; j++)
				{
					px[num8 + j] = c;
				}
			}
			dirty = true;
		}

		public void Flush()
		{
			if (dirty)
			{
				dirty = false;
				tex.SetPixels32(px);
				tex.Apply(false, false);
			}
		}

		public void Destroy()
		{
			if ((Object)(object)tex != (Object)null)
			{
				Object.Destroy((Object)(object)tex);
			}
		}
	}
	internal class RaceGame : IMiniGame
	{
		internal class MatchConfig
		{
			public uint matchId;

			public uint seed;

			public uint[] ids;

			public byte[] colorways;

			public byte round;

			public byte[] wins;
		}

		private enum Mode
		{
			Ready,
			Countdown,
			Racing,
			Out,
			RoundOver
		}

		private class Crate
		{
			public int lane;

			public int col;

			public float baseY;

			public bool broken;
		}

		private class Ghost
		{
			public uint id;

			public Image img;

			public RectTransform rect;

			public float animT;

			public float lastSnapAt;

			public float lastSnapH;

			public bool hStable;
		}

		private class SpeedLine
		{
			public float x;

			public float y;

			public float len;

			public float life;
		}

		private struct GhostView
		{
			public RaceSpectate.Snapshot snap;

			public bool fresh;

			public bool present;

			public bool currentRound;

			public int laps;

			public float extrapS;
		}

		private enum SwingHit
		{
			None,
			Wall,
			Crate
		}

		private enum SegKind : byte
		{
			Straight,
			Arc,
			Shaft
		}

		private class Seg
		{
			public SegKind kind;

			public float s0;

			public float len;

			public int dir;

			public int level = -1;

			public float xA;

			public float yA;

			public float xB;

			public float yB;

			public float r1;

			public float r2;

			public float vLen;

			public bool up;

			public bool boost;

			public int linkA;

			public int linkB;
		}

		private enum TileKind : byte
		{
			Start,
			Landing,
			Sprint,
			Fork,
			Bridge,
			Terrace,
			CrateAlley,
			Pinch,
			Ridge,
			Dive,
			Summit
		}

		private struct TilePlan
		{
			public TileKind kind;

			public float t0;

			public float t1;
		}

		private class LevelPlan
		{
			public int level;

			public int dir;

			public float x0;

			public float x1;

			public float y0;

			public float yExit;

			public readonly List<float> cpT = new List<float>();

			public readonly List<float> cpY = new List<float>();

			public readonly List<TilePlan> tiles = new List<TilePlan>();
		}

		private const float CellPx = 3f;

		private const int LaneCells = 64;

		private const float PlayerW = 12f;

		private const float PlayerH = 22f;

		private const float PlayerScale = 2f;

		private const int WindowsWide = 4;

		private const int BandMouthCells = 8;

		private const int BandCells = 4;

		private const int BandLowCells = 30;

		private const int BandBreakCols = 64;

		private const float BandTopPx = 102f;

		private const float BendGravityScale = 0.5f;

		private const float ShaftBoostFloor = 430f;

		private const float SpeedLineMin = 400f;

		private const float SpeedLineLife = 0.22f;

		private const float StairPx = 7f;

		private const float Gravity = 1900f;

		private const float JumpV = 430f;

		private const float CrawlSpeed = 90f;

		private const float LaunchSpeed = 60f;

		private const float MaxSpeed = 470f;

		private const float Accel = 110f;

		private const float FlingDecay = 400f;

		private const float SwingSpeedCap = 587.5f;

		private const float SlopeSpeedGain = 1.15f;

		private const float HillSpeedFloor = 250f;

		private const float SlopeLookAheadPx = 15f;

		private const float RopeScanMin = 15f;

		private const float RopeScanMax = 145f;

		private const float RopeTuck = 0.78f;

		private const float RopeTuckPxS = 480f;

		private const float RopeRetrySeconds = 0.1f;

		private const float ElimGraceSeconds = 2f;

		private const float CutHoldSeconds = 0.4f;

		private const float CountdownSeconds = 2f;

		private const float StartLineS = 80f;

		private const float GhostStaleSeconds = 1.2f;

		private const float PresenceSeconds = 6f;

		private const float VerdictDebounceSeconds = 1f;

		private const float NeverRacedGraceSeconds = 10f;

		private const float JoinLateProgressPx = 215f;

		private const float HitchDetectSeconds = 0.25f;

		private const float HitchAmnestyCapSeconds = 4f;

		private static float sessionBestLap;

		private ArcadeContext ctx;

		private MatchConfig cfg;

		private PixelSurface surface;

		private Image player;

		private RectTransform playerRect;

		private readonly List<Ghost> ghosts = new List<Ghost>();

		private UiKit.Label leftLabel;

		private UiKit.Label rightLabel;

		private UiKit.Label message;

		private string profileKey;

		private uint ownerNetId;

		private float nextSnapshotAt;

		private int wCells;

		private float ww;

		private float worldHpx;

		private float laneHPx;

		private float loopLen;

		private float camHalfW;

		private float contentHalfH;

		private byte[][] slabH;

		private byte[][] stalD;

		private byte[][] midLo;

		private byte[][] midHi;

		private readonly List<Crate> crates = new List<Crate>();

		private Mode mode;

		private int colorway;

		private float s;

		private float h;

		private float vy;

		private float speed;

		private bool grounded;

		private int laps;

		private int pendingRecross;

		private float animT;

		private float camX;

		private float camY;

		private float leaderTotalD;

		private float goAt;

		private float crashFlashT;

		private readonly List<SpeedLine> speedLines = new List<SpeedLine>();

		private float nextSpeedLineAt;

		private bool roping;

		private float anchorX;

		private float anchorY;

		private float ropeLen;

		private float swingVx;

		private float swingVy;

		private float ropeRetryAt;

		private float lapT;

		private float lastLap;

		private int round;

		private bool spectatorOnly;

		private byte[] wins = Array.Empty<byte>();

		private uint roundWinner;

		private bool winnerTaken;

		private float roundCloseSince;

		private float cutBehindSince;

		private float joinWatchUntil;

		private float hitchGraceUntil;

		private uint rngState;

		private short[] dcRow;

		private byte[] dcLen;

		private byte[] dcShade;

		private int[] dcStart;

		private byte[] dcCount;

		private readonly List<(int col, short row, byte len, byte shade)> dcBuild = new List<(int, short, byte, byte)>();

		private readonly byte[] dcCanvas = new byte[1760];

		private short[] dsRow;

		private byte[] dsLen;

		private byte[] dsShade;

		private int[] dsStart;

		private byte[] dsCount;

		private readonly List<(int col, short row, byte len, byte shade)> dsBuild = new List<(int, short, byte, byte)>();

		private readonly RaceSnapshotMessage snapshotMsg = new RaceSnapshotMessage();

		private static readonly Color32 ColCrate = new Color32((byte)150, (byte)108, (byte)52, byte.MaxValue);

		private static readonly Color32 ColCrateEdge = new Color32((byte)96, (byte)66, (byte)30, byte.MaxValue);

		private static readonly Color32 ColBoost = new Color32((byte)90, (byte)190, (byte)80, byte.MaxValue);

		private static readonly Color32 ColRope = new Color32((byte)230, (byte)230, (byte)218, byte.MaxValue);

		private static readonly Color32 ColCheckA = new Color32((byte)222, (byte)222, (byte)216, byte.MaxValue);

		private static readonly Color32 ColCheckB = new Color32((byte)42, (byte)42, (byte)46, byte.MaxValue);

		private static readonly Color32 ColAir = new Color32((byte)0, (byte)0, (byte)0, (byte)0);

		private int hudLaps = -1;

		private int hudLapTenths = -1;

		private float hudLastLap = -1f;

		private float hudBestLap = -1f;

		private int hudRound = -1;

		private byte[] hudWins;

		private float hudNamesAt;

		private readonly StringBuilder hudSb = new StringBuilder(96);

		private GhostView[] ghostViews = Array.Empty<GhostView>();

		private const byte DressCaps = 1;

		private const byte DressMotes = 2;

		private const byte DressStrata = 4;

		private const byte DressGlow = 8;

		private ArcadeThemes.Theme theme;

		private Color32 deepDark;

		private Color32 midDark;

		private Color32 slabDark;

		private Color32 tunnelBg;

		private Color32 dcDark;

		private Color32 dcMid;

		private Color32 dcAccent;

		private const int MaxLevels = 10;

		private const int MaxSpans = 10;

		private const int MinRockCells = 4;

		private const float MinLevelLen = 700f;

		private const float WaveFadePx = 140f;

		private const float CalmFeatherPx = 60f;

		private const float LevelWanderPx = 170f;

		private const float LedgeMin = 170f;

		private const float LedgeMax = 380f;

		private const float RiseMin = 236f;

		private const float RiseArcMax = 430f;

		private readonly List<Seg> segs = new List<Seg>();

		private float[][] floorTab;

		private short[] ropeCol0;

		private short[] ropeCol1;

		private short[] rockLo;

		private short[] rockHi;

		private byte[] rockN;

		private short[] featRow;

		private sbyte[] featLevel;

		private byte[] featN;

		private int worldRows;

		private int startCol;

		private readonly List<(int c0, int c1, short lo, short hi)> boostBoxes = new List<(int, int, short, short)>();

		private const int LayoutAttemptCap = 64;

		private const uint FailsafeLayoutRng = 1u;

		internal uint MatchId => cfg?.matchId ?? 0;

		internal int RoundIndex => round;

		private bool SelfAlive
		{
			get
			{
				if (mode != Mode.Racing && mode != Mode.Countdown)
				{
					return mode == Mode.Ready;
				}
				return true;
			}
		}

		public void Start(ArcadeContext c)
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			ctx = c;
			cfg = c.raceMatch;
			profileKey = ArcadeLocal.ProfileKey();
			ownerNetId = ArcadeLocal.NetId();
			float num = UserLifetimeStats.RaceBestLap(profileKey);
			if (num > 0f && (sessionBestLap <= 0f || num < sessionBestLap))
			{
				sessionBestLap = num;
			}
			int num2 = Mathf.CeilToInt(ctx.width / 3f);
			surface = new PixelSurface("raceWorld", (Transform)(object)ctx.panel, num2, Mathf.CeilToInt(ctx.height / 3f), 3f);
			camHalfW = ctx.width * 0.5f;
			contentHalfH = ctx.height * 0.5f;
			wCells = num2 * 4;
			ww = (float)wCells * 3f;
			laneHPx = 192f;
			slabH = new byte[10][];
			stalD = new byte[10][];
			midLo = new byte[10][];
			midHi = new byte[10][];
			for (int i = 0; i < 10; i++)
			{
				slabH[i] = new byte[wCells];
				stalD[i] = new byte[wCells];
				midLo[i] = new byte[wCells];
				midHi[i] = new byte[wCells];
			}
			AllocTrack();
			GameObject val = new GameObject("racePlayer");
			val.transform.SetParent((Transform)(object)ctx.panel, false);
			player = val.AddComponent<Image>();
			((Graphic)player).raycastTarget = false;
			playerRect = ((Graphic)player).rectTransform;
			playerRect.pivot = new Vector2(0.5f, 0f);
			playerRect.sizeDelta = CommandoSprites.CommandoSize * 2f;
			if (cfg != null)
			{
				RaceSpectate.Clear();
				RaceSpectate.ActiveMatchId = cfg.matchId;
				colorway = ColorwayOf(ownerNetId);
				round = -1;
				wins = (byte[])cfg.wins.Clone();
				spectatorOnly = true;
				uint[] ids = cfg.ids;
				for (int j = 0; j < ids.Length; j++)
				{
					if (ids[j] == ownerNetId)
					{
						spectatorOnly = false;
					}
				}
				ids = cfg.ids;
				foreach (uint num3 in ids)
				{
					if (num3 != ownerNetId)
					{
						GameObject val2 = new GameObject("raceGhost");
						val2.transform.SetParent((Transform)(object)ctx.panel, false);
						Image val3 = val2.AddComponent<Image>();
						((Graphic)val3).raycastTarget = false;
						((Graphic)val3).color = new Color(1f, 1f, 1f, 0.88f);
						RectTransform rectTransform = ((Graphic)val3).rectTransform;
						rectTransform.pivot = new Vector2(0.5f, 0f);
						rectTransform.sizeDelta = CommandoSprites.CommandoSize * 2f;
						val2.SetActive(false);
						ghosts.Add(new Ghost
						{
							id = num3,
							img = val3,
							rect = rectTransform
						});
					}
				}
				((Transform)playerRect).SetAsLastSibling();
			}
			else
			{
				colorway = ArcadeLocal.PreferredColorway();
			}
			leftLabel = UiKit.CreateLabel("raceLeft", (Transform)(object)ctx.panel, 13f, UiKit.TextPale, (TextAnchor)3);
			leftLabel.Rect.sizeDelta = new Vector2(560f, 18f);
			leftLabel.Rect.anchoredPosition = new Vector2(0f - camHalfW + 286f, contentHalfH - 12f);
			rightLabel = UiKit.CreateLabel("raceRight", (Transform)(object)ctx.panel, 13f, UiKit.TextDim, (TextAnchor)5);
			rightLabel.Rect.sizeDelta = new Vector2(220f, 18f);
			rightLabel.Rect.anchoredPosition = new Vector2(camHalfW - 116f, contentHalfH - 12f);
			message = UiKit.CreateLabel("raceMsg", (Transform)(object)ctx.panel, 15f, UiKit.Gold, (TextAnchor)4);
			message.Rect.sizeDelta = new Vector2(ctx.width - 20f, 22f);
			message.Rect.anchoredPosition = new Vector2(0f, 26f);
			message.Bold();
			if (cfg == null)
			{
				BuildTrack(ctx.seed | 1);
				ResetRacer();
				mode = Mode.Ready;
				message.Text = "SPACE / CLICK jumps — RIGHT-CLICK ropes";
			}
			else
			{
				ApplyMatchState(cfg.round, cfg.wins, joining: true);
			}
		}

		private void AllocDecor()
		{
			dcStart = new int[wCells];
			dcCount = new byte[wCells];
			dsStart = new int[wCells];
			dsCount = new byte[wCells];
		}

		private void ClearDecor()
		{
			dcBuild.Clear();
		}

		private void BakeDressing()
		{
			dsBuild.Clear();
			bool flag = (theme.dress & 4) != 0;
			bool flag2 = (theme.dress & 8) != 0;
			bool flag3 = (theme.dress & 2) != 0;
			if (flag || flag2 || flag3)
			{
				for (int i = 2; i < wCells - 2; i++)
				{
					int num = rockN[i];
					int num2 = 0;
					for (int j = 0; j <= num; j++)
					{
						int num3 = ((j < num) ? rockLo[i * 10 + j] : worldRows);
						if (flag || flag2)
						{
							byte b = (byte)((j == 0 || j == num) ? 1u : 2u);
							int num4 = 0;
							byte b2 = 0;
							for (int k = num2; k <= num3; k++)
							{
								byte b3 = 0;
								if (k < num3)
								{
									if (flag && ArcadeThemes.StrataBand(i, k, 4, 0, drift: true, 9, 2))
									{
										b3 = b;
									}
									if (flag2 && ArcadeThemes.AccentSeed(i, k, 127))
									{
										b3 = 3;
									}
								}
								if (b3 != b2)
								{
									if (b2 != 0)
									{
										dsBuild.Add((i, (short)num4, (byte)(k - num4), b2));
									}
									b2 = b3;
									num4 = k;
								}
							}
						}
						if (j >= num)
						{
							continue;
						}
						int num5 = rockHi[i * 10 + j];
						if (flag3)
						{
							for (int l = num3; l < num5; l++)
							{
								if (ArcadeThemes.AccentSeed(i, l, 211))
								{
									dsBuild.Add((i, (short)l, 1, 3));
								}
							}
						}
						num2 = num5;
					}
				}
			}
			int count = dsBuild.Count;
			dsRow = new short[count];
			dsLen = new byte[count];
			dsShade = new byte[count];
			Array.Clear(dsCount, 0, wCells);
			for (int m = 0; m < count; m++)
			{
				(int, short, byte, byte) tuple = dsBuild[m];
				dsRow[m] = tuple.Item2;
				dsLen[m] = tuple.Item3;
				dsShade[m] = tuple.Item4;
				if (dsCount[tuple.Item1] == 0)
				{
					dsStart[tuple.Item1] = m;
				}
				if (dsCount[tuple.Item1] < byte.MaxValue)
				{
					dsCount[tuple.Item1]++;
				}
			}
			dsBuild.Clear();
		}

		private void PlaceDecor(List<LevelPlan> lvls)
		{
			dcBuild.Clear();
			foreach (LevelPlan lvl in lvls)
			{
				int num = Mathf.Max((int)(Mathf.Min(lvl.x0, lvl.x1) / 3f) + 6, 0);
				int num2 = Mathf.Min((int)(Mathf.Max(lvl.x0, lvl.x1) / 3f) - 6, wCells - 1);
				int level = lvl.level;
				int num3 = num + 6 + Rng(8);
				for (int i = num; i <= num2; i++)
				{
					if (midHi[level][i] == 0 || i < num3)
					{
						continue;
					}
					if (slabH[level][i] > 0)
					{
						num3 = i + 4;
						continue;
					}
					int num4 = Mathf.RoundToInt(floorTab[level][i] / 3f);
					int num5 = midLo[level][i];
					if (num5 >= 5)
					{
						Run(i, num4, num5 - 1, 1);
						Run(i + 1, num4, num5 - 1, 1);
						Run(i - 1, num4 + num5 - 2, 2, 2);
						Run(i + 2, num4 + num5 - 2, 2, 2);
						Run(i, num4, 1, 2);
						Run(i + 1, num4, 1, 2);
					}
					num3 = i + 15 + Rng(9);
				}
				int num6 = num + 12 + Rng(40);
				while (num6 < num2 - 24)
				{
					bool flag = false;
					for (int j = num6 - 2; j <= num6 + 16; j++)
					{
						if (flag)
						{
							break;
						}
						int num7 = Mathf.Clamp(j, 0, wCells - 1);
						flag = slabH[level][num7] > 0 || midHi[level][num7] > 0 || stalD[level][num7] > 0;
					}
					if (level == 0 && Mathf.Abs(num6 - startCol) < 16)
					{
						flag = true;
					}
					if (flag)
					{
						num6 += 10;
						continue;
					}
					int num8 = Rng(100);
					int num9 = ((num8 < 62) ? Rng(16) : ((num8 < 84) ? (16 + Rng(5)) : (21 + Rng(4))));
					int num10 = DecorStamps.Raster(num9, dcCanvas, ref rngState);
					int num11 = num10 >> 8;
					int num12 = num10 & 0xFF;
					int num13 = Mathf.RoundToInt(floorTab[level][Mathf.Clamp(num6 + num11 / 2, 0, wCells - 1)] / 3f);
					int num14;
					if (num9 < 21)
					{
						num14 = ((num9 < 16) ? (num13 - 1) : (num13 + 64 - num12));
					}
					else
					{
						num14 = EmbedRow(num6 + num11 / 2, num13, num12);
						if (num14 < 0)
						{
							num6 += 14;
							continue;
						}
					}
					EmitCanvas(num6, num14, num11, num12);
					num6 += 34 + Rng(56);
				}
			}
			dcBuild.Sort(((int col, short row, byte len, byte shade) a, (int col, short row, byte len, byte shade) b) => a.col.CompareTo(b.col));
			int count = dcBuild.Count;
			dcRow = new short[count];
			dcLen = new byte[count];
			dcShade = new byte[count];
			Array.Clear(dcCount, 0, wCells);
			for (int num15 = 0; num15 < count; num15++)
			{
				(int, short, byte, byte) tuple = dcBuild[num15];
				dcRow[num15] = tuple.Item2;
				dcLen[num15] = tuple.Item3;
				dcShade[num15] = tuple.Item4;
				if (dcCount[tuple.Item1] == 0)
				{
					dcStart[tuple.Item1] = num15;
				}
				if (dcCount[tuple.Item1] < byte.MaxValue)
				{
					dcCount[tuple.Item1]++;
				}
			}
		}

		private void Run(int col, int row, int len, byte shade)
		{
			if (col >= 2 && col < wCells - 2 && len > 0)
			{
				dcBuild.Add((col, (short)row, (byte)Mathf.Min(len, 255), shade));
			}
		}

		private int EmbedRow(int c, int floorRow, int h)
		{
			c = Mathf.Clamp(c, 0, wCells - 1);
			int num = floorRow + 64;
			for (int i = 0; i < rockN[c]; i++)
			{
				int num2 = rockHi[c * 10 + i];
				if (num2 >= num - 2 && num2 <= num + 2)
				{
					int num3 = ((i + 1 < rockN[c]) ? rockLo[c * 10 + i + 1] : worldRows) - num2;
					if (num3 < h + 6)
					{
						return -1;
					}
					return num2 + (num3 - h) / 2;
				}
			}
			return -1;
		}

		private void EmitCanvas(int col, int row0, int w, int h)
		{
			for (int i = 0; i < w; i++)
			{
				int j = 0;
				while (j < h)
				{
					byte b = dcCanvas[j * 40 + i];
					if (b == 0)
					{
						j++;
						continue;
					}
					int num = j;
					for (; j < h && dcCanvas[j * 40 + i] == b; j++)
					{
					}
					Run(col + i, row0 + num, j - num, b);
				}
			}
		}

		private void MaybeBroadcast()
		{
			if (cfg != null && ownerNetId != 0 && !spectatorOnly && (NetworkServer.active || NetworkClient.active) && !(Time.unscaledTime < nextSnapshotAt))
			{
				nextSnapshotAt = Time.unscaledTime + 1f / 30f;
				byte state = (byte)(((mode == Mode.Out) ? 1u : 0u) | (uint)(roping ? 2 : 0) | (uint)((mode == Mode.Racing) ? 4 : 0));
				snapshotMsg.Set(ownerNetId, cfg.matchId, (byte)round, (byte)colorway, state, (ushort)Mathf.Clamp(s * 0.5f, 0f, 65535f), (byte)Mathf.Clamp(h, 0f, 255f), (byte)Mathf.Clamp(Mathf.Abs(speed) / 3f, 0f, 255f), (byte)Mathf.Clamp(laps + 1, 0, 255), (ushort)Mathf.Clamp(roping ? (anchorX * 0.5f) : 0f, 0f, 65535f));
				if (NetworkServer.active)
				{
					NetMessageExtensions.Send((INetMessage)(object)snapshotMsg, (NetworkDestination)1);
				}
				else
				{
					NetMessageExtensions.Send((INetMessage)(object)snapshotMsg, (NetworkDestination)2);
				}
			}
		}

		public void End()
		{
			if (cfg != null && RaceSpectate.ActiveMatchId == cfg.matchId)
			{
				RaceSpectate.ActiveMatchId = 0u;
				RaceSpectate.Clear();
			}
			surface?.Destroy();
		}

		private void DrawWorld()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_082b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0830: Unknown result type (might be due to invalid IL or missing references)
			//IL_0833: Unknown result type (might be due to invalid IL or missing references)
			//IL_083a: 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_07a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0903: Unknown result type (might be due to invalid IL or missing references)
			surface.Clear(ColAir);
			float num = camX - camHalfW;
			float num2 = camY - contentHalfH;
			int num3 = Mathf.FloorToInt(num / 3f);
			int num4 = Mathf.FloorToInt(num2 / 3f);
			bool flag = (theme.dress & 1) != 0;
			for (int i = 0; i < surface.W; i++)
			{
				int num5 = num3 + i;
				if (num5 < 2 || num5 >= wCells - 2)
				{
					surface.FillRect(i, 0, 1, surface.H, theme.deep);
					continue;
				}
				int num6 = rockN[num5];
				int num7 = 0;
				for (int j = 0; j <= num6; j++)
				{
					int num8 = ((j < num6) ? rockLo[num5 * 10 + j] : worldRows);
					surface.FillRect(i, num7 - num4, 1, num8 - num7, (j == 0 || j == num6) ? theme.deep : theme.mid);
					if (j < num6)
					{
						num7 = rockHi[num5 * 10 + j];
					}
				}
				int num9 = dsCount[num5];
				for (int k = 0; k < num9; k++)
				{
					int num10 = dsStart[num5] + k;
					Color32 c = ((dsShade[num10] == 1) ? deepDark : ((dsShade[num10] == 2) ? midDark : theme.cap));
					surface.FillRect(i, dsRow[num10] - num4, 1, dsLen[num10], c);
				}
				int num11 = featN[num5];
				for (int l = 0; l < num11; l++)
				{
					int num12 = featLevel[num5 * 10 + l];
					int num13 = midLo[num12][num5];
					if (midHi[num12][num5] > 0 && num13 > 1)
					{
						surface.FillRect(i, featRow[num5 * 10 + l] - num4, 1, num13, tunnelBg);
					}
				}
				int num14 = dcCount[num5];
				for (int m = 0; m < num14; m++)
				{
					int num15 = dcStart[num5] + m;
					Color32 c2 = ((dcShade[num15] == 1) ? dcDark : ((dcShade[num15] == 2) ? dcMid : dcAccent));
					surface.FillRect(i, dcRow[num15] - num4, 1, dcLen[num15], c2);
				}
				for (int n = 0; n < num11; n++)
				{
					int num16 = featLevel[num5 * 10 + n];
					int num17 = featRow[num5 * 10 + n];
					int num18 = num17 + 64 - 1;
					int num19 = slabH[num16][num5];
					for (int num20 = 0; num20 < num19; num20++)
					{
						surface.Set(i, num17 + num20 - num4, ((((num17 + num20) % 3 == 2) ^ ((num5 & 4) != 0)) && num20 < num19 - 1) ? slabDark : theme.slab);
					}
					int num21 = midLo[num16][num5];
					int num22 = midHi[num16][num5];
					if (num22 > 0)
					{
						for (int num23 = num21; num23 < num22; num23++)
						{
							surface.Set(i, num17 + num23 - num4, ((num17 + num23) % 3 == 2 && num23 > num21 && num23 < num22 - 1) ? slabDark : theme.slab);
						}
						surface.Set(i, num17 + num21 - num4, theme.stal);
					}
					int num24 = stalD[num16][num5];
					if (num24 > 0)
					{
						surface.FillRect(i, num18 - num24 + 1 - num4, 1, num24, theme.stal);
					}
					if (flag)
					{
						surface.Set(i, num17 - 1 - num4, theme.cap);
						if (num19 > 0)
						{
							surface.Set(i, num17 + num19 - 1 - num4, theme.cap);
						}
						if (num22 > 0)
						{
							surface.Set(i, num17 + num22 - 1 - num4, theme.cap);
						}
					}
				}
			}
			int num25 = startCol - num3;
			if (num25 >= 0 && num25 < surface.W)
			{
				int num26 = Mathf.RoundToInt(floorTab[0][startCol] / 3f);
				for (int num27 = 0; num27 < 64; num27++)
				{
					int y = num26 + num27 - num4;
					if (surface.Get(num25, y).a == 0)
					{
						surface.Set(num25, y, (((num27 >> 1) & 1) == 0) ? ColCheckA : ColCheckB);
					}
				}
			}
			Color32 c3 = default(Color32);
			foreach (SpeedLine speedLine in speedLines)
			{
				int y2 = Mathf.RoundToInt((speedLine.y - num2) / 3f);
				int num28 = Mathf.RoundToInt((speedLine.x - num) / 3f);
				int num29 = Mathf.Max(2, (int)(speedLine.len / 3f));
				((Color32)(ref c3))..ctor((byte)225, (byte)232, (byte)240, (byte)(200f * speedLine.life / 0.22f));
				for (int num30 = 0; num30 < num29; num30++)
				{
					if (surface.Get(num28 + num30, y2).a == 0)
					{
						surface.Set(num28 + num30, y2, c3);
					}
				}
			}
			int num31 = (int)(Time.unscaledTime * 10f) % 9;
			foreach (var boostBox in boostBoxes)
			{
				if (boostBox.c1 >= num3 && boostBox.c0 <= num3 + surface.W)
				{
					int num32 = (boostBox.c0 + boostBox.c1) / 2 - num3;
					for (int num33 = boostBox.lo + 4 + num31; num33 < boostBox.hi - 4; num33 += 9)
					{
						surface.Set(num32, num33 - num4, ColBoost);
						surface.Set(num32 - 1, num33 - num4 - 1, ColBoost);
						surface.Set(num32 + 1, num33 - num4 - 1, ColBoost);
					}
				}
			}
			foreach (Crate crate in crates)
			{
				if (!crate.broken)
				{
					float num34 = (float)crate.col * 3f;
					if (!(num34 + 18f < num) && !(num34 > num + ctx.width))
					{
						int num35 = Mathf.RoundToInt((num34 - num) / 3f);
						int num36 = Mathf.RoundToInt(FloorWorldY(crate.lane, num34 + 9f) / 3f) + (int)(crate.baseY / 3f) - num4;
						surface.FillRect(num35, num36, 6, 6, ColCrateEdge);
						surface.FillRect(num35 + 1, num36 + 1, 4, 4, ColCrate);
						surface.Set(num35 + 2, num36 + 2, ColCrateEdge);
						surface.Set(num35 + 3, num36 + 3, ColCrateEdge);
					}
				}
			}
			int facing;
			bool inBend;
			if (roping)
			{
				int lane;
				Vector2 val = MapPath(s, h, out lane, out facing, out inBend);
				DrawRope(val.x, val.y + 15.4f, anchorX, anchorY, num, num2);
			}
			for (int num37 = 0; num37 < ghostViews.Length; num37++)
			{
				GhostView ghostView = ghostViews[num37];
				if (ghostView.snap != null && ghostView.fresh && ghostView.currentRound && ghostView.snap.roping && !ghostView.snap.dead)
				{
					int lane2;
					Vector2 val2 = MapPath(ghostView.extrapS, ghostView.snap.h, out lane2, out facing, out inBend);
					int c4 = Mathf.Clamp((int)(ghostView.snap.anchorX / 3f), 0, wCells - 1);
					DrawRope(val2.x, val2.y + 15.4f, ghostView.snap.anchorX, RopeAnchorY(lane2, c4, ghostView.snap.anchorX, ghostView.snap.h), num, num2);
				}
			}
		}

		private void DrawRope(float x0, float y0, float x1, float y1, float camLeft, float camBottom)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt((x0 - camLeft) / 3f);
			int num2 = Mathf.RoundToInt((y0 - camBottom) / 3f);
			int num3 = Mathf.RoundToInt((x1 - camLeft) / 3f);
			int num4 = Mathf.RoundToInt((y1 - camBottom) / 3f);
			int num5 = Mathf.Max(Mathf.Abs(num3 - num), Mathf.Abs(num4 - num2));
			for (int i = 0; i <= num5; i++)
			{
				float num6 = ((num5 == 0) ? 0f : ((float)i / (float)num5));
				surface.Set(Mathf.RoundToInt(Mathf.Lerp((float)num, (float)num3, num6)), Mathf.RoundToInt(Mathf.Lerp((float)num2, (float)num4, num6)), ColRope);
			}
		}

		private void DrawRacers(float dt)
		{
			if (grounded && mode == Mode.Racing)
			{
				animT += dt * Mathf.Max(Mathf.Abs(speed), 60f) / 160f;
			}
			PlaceRacer(playerRect, player, s, h, colorway, grounded && mode != Mode.Out, mode == Mode.Out, crashFlashT > 0f, animT);
			for (int i = 0; i < ghostViews.Length; i++)
			{
				Ghost ghost = ghosts[i];
				GhostView ghostView = ghostViews[i];
				bool flag = ghostView.snap != null && ghostView.fresh && ghostView.currentRound && !ghostView.snap.dead;
				if (((Component)ghost.img).gameObject.activeSelf != flag)
				{
					((Component)ghost.img).gameObject.SetActive(flag);
				}
				if (flag)
				{
					float sIn = (ghostView.snap.racing ? ghostView.extrapS : ghostView.snap.s);
					bool flag2 = ghost.hStable && !ghostView.snap.roping;
					if (flag2 && ghostView.snap.racing)
					{
						ghost.animT += dt * Mathf.Max(ghostView.snap.speedPxS, 60f) / 160f;
					}
					PlaceRacer(ghost.rect, ghost.img, sIn, ghostView.snap.h, ghostView.snap.colorway, flag2, dimmed: false, flash: false, ghost.animT);
				}
			}
		}

		private void PlaceRacer(RectTransform rt, Image img, float sIn, float hIn, int cw, bool walking, bool dimmed, bool flash, float animClock)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_008d: 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_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_0049: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			int lane;
			int facing;
			bool inBend;
			Vector2 val = MapPath(sIn, hIn, out lane, out facing, out inBend);
			rt.anchoredPosition = new Vector2(val.x - camX, val.y - camY);
			float num = 0f;
			if (inBend)
			{
				Seg leadSeg;
				Vector2 val2 = PathDir(sIn, out leadSeg);
				num = Mathf.Atan2(val2.y, val2.x) * 57.29578f;
				if (num > 90f || num < -90f)
				{
					facing = -1;
					num += 180f;
				}
				else
				{
					facing = 1;
				}
			}
			((Transform)rt).localRotation = Quaternion.Euler(0f, 0f, num);
			((Transform)rt).localScale = new Vector3((float)facing, 1f, 1f);
			img.sprite = CommandoSprites.CommandoFrame(cw, walking ? animClock : 0.06f);
			Color val3 = (Color)(dimmed ? new Color(1f, 1f, 1f, 0.35f) : (((Object)(object)img == (Object)(object)player) ? Color.white : ((Graphic)img).color));
			if (flash)
			{
				((Color)(ref val3))..ctor(1f, 0.5f, 0.4f, val3.a);
			}
			((Graphic)img).color = val3;
		}

		private void UpdateHud()
		{
			if (cfg == null)
			{
				int num = ((mode == Mode.Racing) ? Mathf.RoundToInt(lapT * 10f) : (-1));
				if (num != hudLapTenths || laps != hudLaps || lastLap != hudLastLap)
				{
					hudLapTenths = num;
					hudLaps = laps;
					hudLastLap = lastLap;
					leftLabel.Text = ((mode == Mode.Racing) ? ($"LAP {laps + 1}   {lapT:0.0}s" + ((lastLap > 0f) ? $"   last {lastLap:0.0}s" : "")) : "");
				}
				if (sessionBestLap != hudBestLap)
				{
					hudBestLap = sessionBestLap;
					rightLabel.Text = ((sessionBestLap > 0f) ? $"best lap {sessionBestLap:0.0}s" : "best lap —");
				}
				return;
			}
			bool flag = round != hudRound || hudWins == null || hudWins.Length != wins.Length || Time.unscaledTime >= hudNamesAt;
			if (!flag)
			{
				for (int i = 0; i < wins.Length; i++)
				{
					if (wins[i] != hudWins[i])
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				return;
			}
			hudNamesAt = Time.unscaledTime + 1f;
			if (hudWins == null || hudWins.Length != wins.Length)
			{
				hudWins = new byte[wins.Length];
			}
			Array.Copy(wins, hudWins, wins.Length);
			hudSb.Clear();
			for (int j = 0; j < cfg.ids.Length; j++)
			{
				if (hudSb.Length > 0)
				{
					hudSb.Append("   ");
				}
				hudSb.Append(NameFor(cfg.ids[j])).Append(' ').Append((wins.Length > j) ? wins[j] : 0);
			}
			leftLabel.Text = hudSb.ToString();
			if (round != hudRound)
			{
				hudRound = round;
				rightLabel.Text = $"ROUND {round + 1}";
			}
		}

		private float TotalDistance()
		{
			return (float)laps * loopLen + s;
		}

		private void UpdateGhostViews()
		{
			if (ghostViews.Length != ghosts.Count)
			{
				ghostViews = new GhostView[ghosts.Count];
			}
			float unscaledTime = Time.unscaledTime;
			for (int i = 0; i < ghosts.Count; i++)
			{
				Ghost ghost = ghosts[i];
				if (!RaceSpectate.Latest.TryGetValue(ghost.id, out var value))
				{
					ghostViews[i] = default(GhostView);
					continue;
				}
				if (value.receivedAt != ghost.lastSnapAt)
				{
					ghost.hStable = Mathf.Abs(value.h - ghost.lastSnapH) <= 1.5f;
					ghost.lastSnapH = value.h;
					ghost.lastSnapAt = value.receivedAt;
				}
				float num = unscaledTime - value.receivedAt;
				ghostViews[i] = new GhostView
				{
					snap = value,
					fresh = (num <= 1.2f),
					present = (num <= 6f),
					currentRound = (value.round == round),
					laps = value.laps - 1,
					extrapS = value.s + value.speedPxS * num
				};
			}
		}

		private void UpdateSpeedLines(float dt)
		{
			for (int num = speedLines.Count - 1; num >= 0; num--)
			{
				speedLines[num].life -= dt;
				if (speedLines[num].life <= 0f)
				{
					speedLines.RemoveAt(num);
				}
			}
			if (Time.unscaledTime < nextSpeedLineAt)
			{
				return;
			}
			nextSpeedLineAt = Time.unscaledTime + 0.035f;
			if (mode == Mode.Racing && Mathf.Abs(speed) >= 400f)
			{
				Spawn(s, h, Mathf.Abs(speed));
			}
			for (int i = 0; i < ghostViews.Length; i++)
			{
				GhostView ghostView = ghostViews[i];
				if (ghostView.snap != null && !ghostView.snap.dead && ghostView.snap.racing && ghostView.currentRound && ghostView.fresh && !(ghostView.snap.speedPxS < 400f))
				{
					Spawn(ghostView.extrapS, ghostView.snap.h, ghostView.snap.speedPxS);
				}
			}
			if (speedLines.Count > 48)
			{
				speedLines.RemoveRange(0, speedLines.Count - 48);
			}
			void Spawn(float sPos, float hPos, float spd)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: 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_0040: Unknown result type (might be due to invalid IL or missing references)
				int lane;
				int facing;
				bool inBend;
				Vector2 val = MapPath(sPos, hPos, out lane, out facing, out inBend);
				if (!inBend)
				{
					speedLines.Add(new SpeedLine
					{
						x = val.x - (float)facing * (8f + Random.value * 24f),
						y = val.y + 3f + Random.value * 20f,
						len = 8f + (spd - 400f) * 0.045f,
						life = 0.22f
					});
				}
			}
		}

		private void UpdateCamera(float dt)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			float num = float.MinValue;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(camX, camY);
			int lane = 0;
			bool inBend = false;
			int facing;
			if (cfg == null || SelfAlive)
			{
				num = TotalDistance();
				val = MapPath(s, h, out lane, out facing, out inBend);
			}
			if (cfg != null)
			{
				for (int i = 0; i < ghostViews.Length; i++)
				{
					GhostView ghostView = ghostViews[i];
					if (ghostView.snap != null && ghostView.fresh && !ghostView.snap.dead && ghostView.currentRound)
					{
						float num2 = (float)ghostView.laps * loopLen + ghostView.extrapS;
						if (num2 > num)
						{
							num = num2;
							val = MapPath(ghostView.extrapS, ghostView.snap.h, out lane, out facing, out inBend);
						}
					}
				}
			}
			if (num > float.MinValue)
			{
				leaderTotalD = num;
				float num3 = Mathf.Clamp(val.x, camHalfW, ww - camHalfW);
				float num4 = (inBend ? (val.y + 30f) : Mathf.Lerp(val.y + 30f, FloorWorldY(lane, val.x) + laneHPx * 0.5f, 0.5f));
				num4 = Mathf.Clamp(num4, contentHalfH, worldHpx - contentHalfH);
				float num5 = 1f - Mathf.Exp(-6f * dt);
				camX = Mathf.Lerp(camX, num3, num5);
				camY = Mathf.Lerp(camY, num4, num5);
			}
		}

		private void CheckRoundOver()
		{
			if (mode == Mode.Ready || Time.unscaledTime < goAt + 2f + 0.5f)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (roundWinner != 0)
			{
				if (winnerTaken || mode != Mode.RoundOver)
				{
					return;
				}
				for (int i = 0; i < ghostViews.Length; i++)
				{
					GhostView ghostView = ghostViews[i];
					if (ghostView.snap != null && ghostView.currentRound && !ghostView.snap.dead && ghostView.snap.racing && ghostView.fresh)
					{
						roundWinner = 0u;
						roundCloseSince = 0f;
						mode = Mode.Racing;
						message.Text = "";
						break;
					}
				}
				return;
			}
			int num = 0;
			uint num2 = 0u;
			float num3 = float.MinValue;
			uint num4 = 0u;
			if (SelfAlive)
			{
				num++;
				num2 = ownerNetId;
			}
			if (!spectatorOnly)
			{
				num3 = (float)(Mathf.Clamp(laps + 1, 0, 255) - 1) * loopLen + (float)(int)(ushort)Mathf.Clamp(s * 0.5f, 0f, 65535f) * 2f;
				num4 = ownerNetId;
			}
			for (int j = 0; j < ghostViews.Length; j++)
			{
				GhostView ghostView2 = ghostViews[j];
				if (ghostView2.snap == null)
				{
					if (round == 0 && unscaledTime < goAt + 10f)
					{
						num++;
						num2 = ghosts[j].id;
					}
					continue;
				}
				if (ghostView2.present && !ghostView2.snap.dead)
				{
					num++;
					num2 = ghosts[j].id;
				}
				if (ghostView2.present && ghostView2.currentRound)
				{
					float num5 = (float)ghostView2.laps * loopLen + ghostView2.snap.s;
					if (num5 > num3 || (num5 == num3 && ghosts[j].id < num4))
					{
						num3 = num5;
						num4 = ghosts[j].id;
					}
				}
			}
			if (num > 1)
			{
				roundCloseSince = 0f;
			}
			else if (roundCloseSince <= 0f)
			{
				roundCloseSince = unscaledTime;
			}
			else if (!(unscaledTime - roundCloseSince < 1f))
			{
				roundWinner = ((num == 1) ? num2 : num4);
				if (roundWinner == 0)
				{
					roundWinner = ownerNetId;
				}
				if (mode != Mode.Out)
				{
					mode = Mode.RoundOver;
				}
				message.Text = NameFor(roundWinner) + " TAKES THE ROUND";
			}
		}

		private static string NameFor(uint netId)
		{
			//IL_001e: 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)
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null)
				{
					NetworkInstanceId netId2 = ((NetworkBehaviour)readOnlyInstances).netId;
					if (((NetworkInstanceId)(ref netId2)).Value == netId)
					{
						return string.IsNullOrEmpty(readOnlyInstances.userName) ? "Player" : readOnlyInstances.userName;
					}
				}
			}
			return "Player";
		}

		private int ColorwayOf(uint netId)
		{
			if (cfg != null)
			{
				for (int i = 0; i < cfg.ids.Length; i++)
				{
					if (cfg.ids[i] == netId)
					{
						return cfg.colorways[i];
					}
				}
			}
			return CommandoSprites.ColorwayFor(netId);
		}

		internal void ApplyMatchState(int newRound, byte[] newWins, bool joining = false)
		{
			if (newWins != null && newWins.Length == cfg.ids.Length)
			{
				wins = (byte[])newWins.Clone();
			}
			if (newRound == round)
			{
				return;
			}
			round = newRound;
			roundWinner = 0u;
			winnerTaken = false;
			roundCloseSince = 0f;
			joinWatchUntil = 0f;
			BuildTrack((cfg.seed ^ (uint)(newRound * -1640531535)) | 1);
			ResetRacer();
			if (spectatorOnly)
			{
				mode = Mode.Out;
				goAt = Time.unscaledTime;
				message.Text = "race is full — spectating";
				return;
			}
			if (joining && newRound > 0)
			{
				mode = Mode.Out;
				goAt = Time.unscaledTime;
				message.Text = "match in progress — in at the next round";
				return;
			}
			mode = Mode.Countdown;
			goAt = Time.unscaledTime + 2f;
			if (joining)
			{
				joinWatchUntil = goAt;
			}
		}

		private bool JoinedLiveRound()
		{
			for (int i = 0; i < ghostViews.Length; i++)
			{
				GhostView ghostView = ghostViews[i];
				if (ghostView.snap != null && ghostView.present && ghostView.currentRound && !ghostView.snap.dead && ghostView.snap.racing && (float)ghostView.laps * loopLen + ghostView.snap.s - 80f > 215f)
				{
					return true;
				}
			}
			return false;
		}

		internal bool TryTakeRoundWinner(out uint winner)
		{
			winner = roundWinner;
			if (roundWinner == 0 || winnerTaken)
			{
				return false;
			}
			winnerTaken = true;
			return true;
		}

		private void ResetRacer()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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)
			s = 80f;
			h = 0f;
			vy = 0f;
			speed = 0f;
			laps = 0;
			pendingRecross = 0;
			grounded = true;
			roping = false;
			animT = 0f;
			lapT = 0f;
			lastLap = 0f;
			crashFlashT = 0f;
			cutBehindSince = 0f;
			int lane;
			int facing;
			bool inBend;
			Vector2 val = MapPath(s, 0f, out lane, out facing, out inBend);
			camX = Mathf.Clamp(val.x, camHalfW, ww - camHalfW);
			camY = Mathf.Clamp(val.y + 30f + laneHPx * 0.25f, contentHalfH, worldHpx - contentHalfH);
			leaderTotalD = TotalDistance();
			message.Text = "";
		}

		public void Tick(float dt)
		{
			if (Time.unscaledDeltaTime > 0.25f)
			{
				hitchGraceUntil = Time.unscaledTime + Mathf.Min(Time.unscaledDeltaTime, 4f);
			}
			switch (mode)
			{
			case Mode.Ready:
				if (ArcadeInput.ActionDown)
				{
					mode = Mode.Countdown;
					goAt = Time.unscaledTime + 1f;
				}
				break;
			case Mode.Countdown:
				if (joinWatchUntil > 0f && JoinedLiveRound())
				{
					joinWatchUntil = 0f;
					mode = Mode.Out;
					goAt = Time.unscaledTime;
					message.Text = "match in progress — in at the next round";
				}
				else if (Time.unscaledTime >= goAt)
				{
					joinWatchUntil = 0f;
					mode = Mode.Racing;
					speed = 60f;
					message.Text = "";
				}
				else
				{
					message.Text = $"READY — {Mathf.CeilToInt(goAt - Time.unscaledTime)}";
				}
				break;
			case Mode.Racing:
				Step(dt);
				break;
			}
			if (cfg != null)
			{
				UpdateGhostViews();
			}
			UpdateCamera(dt);
			if (cfg != null)
			{
				CheckRoundOver();
			}
			UpdateSpeedLines(dt);
			DrawWorld();
			DrawRacers(dt);
			UpdateHud();
			surface.Flush();
			MaybeBroadcast();
		}

		private void Step(float dt)
		{
			//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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: 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)
			int lane;
			int facing;
			bool inBend;
			Vector2 val = MapPath(s, h, out lane, out facing, out inBend);
			if (ArcadeInput.ActionDown && !inBend && grounded && !roping)
			{
				vy = 430f;
				grounded = false;
			}
			if (!inBend && !roping && (ArcadeInput.RopeDown || (ArcadeInput.RopeHeld && Time.unscaledTime >= ropeRetryAt)))
			{
				ropeRetryAt = Time.unscaledTime + 0.1f;
				TryFireRope(lane, facing);
			}
			if (roping && !ArcadeInput.RopeHeld)
			{
				DetachRope();
			}
			if (roping)
			{
				StepSwing(dt, lane, facing);
			}
			else
			{
				float num = 470f;
				if (grounded && !inBend)
				{
					float num2 = (FloorWorldY(lane, val.x + (float)facing * 15f) - FloorWorldY(lane, val.x)) / 15f;
					num = Mathf.Clamp(470f * (1f - 1.15f * num2), 250f, 587.5f);
				}
				if (speed < num)
				{
					speed = Mathf.Min(num, speed + 110f * dt);
				}
				else
				{
					speed = Mathf.Max(num, speed - 400f * dt);
				}
				if (inBend)
				{
					h = Mathf.Max(0f, h - 300f * dt);
					vy = 0f;
					grounded = true;
					Seg leadSeg;
					Vector2 val2 = PathDir(s, out leadSeg);
					speed += 1900f * (0f - val2.y) * 0.5f * dt;
					if (leadSeg.boost)
					{
						speed = Mathf.Max(speed, 430f);
					}
					speed = Mathf.Min(speed, 587.5f);
					Advance(speed * dt, lane);
				}
				else
				{
					vy -= 1900f * dt;
					h += vy * dt;
					Advance(speed * dt, lane);
					ResolveVertical(lane, h - vy * dt);
				}
			}
			if (s >= loopLen)
			{
				s -= loopLen;
				laps++;
				if (pendingRecross > 0)
				{
					pendingRecross--;
				}
				else if (cfg == null)
				{
					lastLap = lapT;
					lapT = 0f;
					if (sessionBestLap <= 0f || lastLap < sessionBestLap)
					{
						sessionBestLap = lastLap;
					}
					UserLifetimeStats.ReportRaceLap(profileKey, lastLap);
				}
			}
			else if (s < 0f)
			{
				s += loopLen;
				laps--;
				pendingRecross++;
			}
			if (cfg == null)
			{
				lapT += dt;
			}
			if (crashFlashT > 0f)
			{
				crashFlashT -= dt;
			}
			if (cfg != null && Time.unscaledTime > goAt + 2f && Time.unscaledTime >= hitchGraceUntil && leaderTotalD - TotalDistance() > camHalfW + 60f)
			{
				if (cutBehindSince <= 0f)
				{
					cutBehindSince = Time.unscaledTime;
				}
				else if (Time.unscaledTime - cutBehindSince >= 0.4f)
				{
					mode = Mode.Out;
					roping = false;
					message.Text = "CUT — watching the round";
				}
			}
			else
			{
				cutBehindSince = 0f;
			}
		}

		private void Advance(float ds, int lane)
		{
			//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)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			float num = ds;
			while (num > 0.01f)
			{
				float num2 = Mathf.Min(num, 3f);
				num -= num2;
				int lane2;
				int facing;
				bool inBend;
				Vector2 val = MapPath(s, 0f, out lane2, out facing, out inBend);
				float sIn = s + num2;
				int lane3;
				int facing2;
				bool inBend2;
				Vector2 val2 = MapPath(sIn, 0f, out lane3, out facing2, out inBend2);
				if (!inBend2)
				{
					if (!grounded && !inBend && lane2 == lane3)
					{
						h += FloorWorldY(lane2, val.x) - FloorWorldY(lane3, val2.x);
					}
					int num3 = Mathf.Clamp((int)((val2.x + (float)facing2 * 6f) / 3f), 0, wCells - 1);
					float num4 = (float)(int)slabH[lane3][num3] * 3f;
					float num5 = (float)(int)midHi[lane3][num3] * 3f;
					if ((num4 > 0f && h < num4 - 7f) || (num5 > 0f && h < num5 - 7f && h + 22f > (float)(int)midLo[lane3][num3] * 3f + 1f))
					{
						speed = 0f;
						crashFlashT = 0.3f;
						break;
					}
					if (grounded)
					{
						float num6 = 0f;
						if (num4 > h && num4 <= h + 7f)
						{
							num6 = num4;
						}
						if (num5 > h && num5 <= h + 7f)
						{
							num6 = Mathf.Max(num6, num5);
						}
						if (num6 > 0f)
						{
							h = num6;
						}
					}
					if (CrateHit(lane3, val2.x))
					{
						s = sIn;
						Crash();
						break;
					}
				}
				s = sIn;
			}
		}

		private bool CrateHit(int lane, float worldX)
		{
			foreach (Crate crate in crates)
			{
				if (!crate.broken && crate.lane == lane)
				{
					float num = (float)crate.col * 3f;
					if (!(worldX + 6f < num) && !(worldX - 6f > num + 18f) && !(h > crate.baseY + 18f) && !(h + 22f < crate.baseY))
					{
						crate.broken = true;
						return true;
					}
				}
			}
			return false;
		}

		private void Crash()
		{
			speed = Mathf.Min(speed, 90f);
			crashFlashT = 0.25f;
		}

		private bool ResolveVertical(int lane, float hPrev)
		{
			//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: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			int lane2;
			int facing;
			bool inBend;
			Vector2 val = MapPath(s, h, out lane2, out facing, out inBend);
			if (inBend)
			{
				return false;
			}
			int num = Mathf.Clamp((int)((val.x - 4.8f) / 3f), 0, wCells - 1);
			int num2 = Mathf.Clamp((int)((val.x + 4.8f) / 3f), 0, wCells - 1);
			float num3 = 0f;
			float num4 = laneHPx;
			for (int i = num; i <= num2; i++)
			{
				float num5 = (float)(int)slabH[lane][i] * 3f;
				if (num5 <= hPrev + 1.5f)
				{
					num3 = Mathf.Max(num3, num5);
				}
				float num6 = (float)(int)midHi[lane][i] * 3f;
				if (num6 > 0f)
				{
					if (num6 <= hPrev + 1.5f)
					{
						num3 = Mathf.Max(num3, num6);
					}
					else if (hPrev + 1f < num6)
					{
						num4 = Mathf.Min(num4, (float)(int)midLo[lane][i] * 3f);
					}
				}
				num4 = Mathf.Min(num4, laneHPx - (float)(int)stalD[lane][i] * 3f);
			}
			bool num7 = h + 22f > num4;
			if (num7)
			{
				h = num4 - 22f;
				vy = Mathf.Min(vy, 0f);
			}
			grounded = h <= num3 + 0.5f && vy <= 0f;
			if (grounded)
			{
				h = num3;
				vy = 0f;
			}
			return num7;
		}

		private void TryFireRope(int lane, int facing)
		{
			//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_0019: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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)
			int lane2;
			int facing2;
			bool inBend;
			Vector2 val = MapPath(s, h, out lane2, out facing2, out inBend);
			int num = Mathf.Clamp((int)((val.x + (float)facing * 145f) / 3f), 0, wCells - 1);
			int num2 = Mathf.Clamp((int)((val.x + (float)facing * 15f) / 3f), 0, wCells - 1);
			float num3 = val.y + 15.4f;
			for (int num4 = num; num4 != num2; num4 -= facing)
			{
				if (num4 >= ropeCol0[lane] && num4 <= ropeCol1[lane] && stalD[lane][num4] == 0)
				{
					float num5 = (float)num4 * 3f + 1.5f;
					float num6 = RopeAnchorY(lane, num4, num5, h);
					if (!(num6 - 6f <= num3))
					{
						float num7 = Vector2.Distance(new Vector2(val.x, num3), new Vector2(num5, num6));
						if (!(num7 < 12f))
						{
							anchorX = num5;
							anchorY = num6;
							ropeLen = num7 * 0.78f;
							roping = true;
							swingVx = speed * (float)facing;
							swingVy = vy;
							break;
						}
					}
				}
			}
		}

		private float RopeAnchorY(int lane, int c, float ax, float hIn)
		{
			int num = midHi[lane][c];
			if (num > 0 && hIn < (float)num * 3f)
			{
				return FloorWorldY(lane, ax) + (float)(int)midLo[lane][c] * 3f;
			}
			return CeilWorldY(lane, ax);
		}

		private void StepSwing(float dt, int lane, int facing)
		{
			//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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_0184: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_010b: 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_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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_013e: 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_0221: 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_01e1: Unknown result type (might be due to invalid IL or missing references)
			int lane2;
			int facing2;
			bool inBend;
			Vector2 val = MapPath(s, h, out lane2, out facing2, out inBend);
			float x = val.x;
			float num = val.y + 15.4f;
			swingVy -= 1900f * dt;
			x += swingVx * dt;
			num += swingVy * dt;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(anchorX, anchorY);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(x, num);
			Vector2 val4 = val3 - val2;
			float magnitude = ((Vector2)(ref val4)).magnitude;
			if (magnitude > 0.001f)
			{
				val4 /= magnitude;
				bool num2 = Mathf.Abs(magnitude - ropeLen) > 2f;
				val3 = val2 + val4 * Mathf.MoveTowards(magnitude, ropeLen, 480f * dt);
				Vector2 val5 = default(Vector2);
				((Vector2)(ref val5))..ctor(swingVx, swingVy);
				Vector2 val6 = default(Vector2);
				((Vector2)(ref val6))..ctor(0f - val4.y, val4.x);
				float num3 = Vector2.Dot(val5, val6);
				val5 = (num2 ? (val6 * (Mathf.Sign(num3) * ((Vector2)(ref val5)).magnitude)) : (val6 * num3));
				if (((Vector2)(ref val5)).magnitude > 587.5f)
				{
					val5 = ((Vector2)(ref val5)).normalized * 587.5f;
				}
				swingVx = val5.x;
				swingVy = val5.y;
			}
			float ds = ((facing > 0) ? (val3.x - val.x) : (val.x - val3.x));
			switch (SwingAdvance(ds, val.y, val3.y - 15.4f, lane))
			{
			case SwingHit.Wall:
				swingVx = 0f;
				speed = 0f;
				DetachRope();
				return;
			case SwingHit.None:
				h = val3.y - 15.4f - FloorWorldY(lane, val3.x);
				break;
			}
			vy = swingVy;
			speed = swingVx * (float)facing;
			MapPath(s, h, out var lane3, out facing2, out var inBend2);
			if (inBend2 || lane3 != lane)
			{
				DetachRope();
				return;
			}
			if (ResolveVertical(lane, h - vy * dt))
			{
				swingVy = Mathf.Min(swingVy, 0f);
			}
			if (grounded)
			{
				DetachRope();
			}
		}

		private SwingHit SwingAdvance(float ds, float bodyY0, float bodyY1, int lane)
		{
			//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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Abs(ds);
			if (num < 0.01f)
			{
				return SwingHit.None;
			}
			int num2 = ((ds >= 0f) ? 1 : (-1));
			float num3 = s;
			float num4 = 0f;
			while (num4 < num - 0.01f)
			{
				num4 = Mathf.Min(num4 + 3f, num);
				float sIn = num3 + (float)num2 * num4;
				int lane2;
				int facing;
				bool inBend;
				Vector2 val = MapPath(sIn, 0f, out lane2, out facing, out inBend);
				if (inBend || lane2 != lane)
				{
					s = sIn;
					continue;
				}
				float num5 = Mathf.Lerp(bodyY0, bodyY1, num4 / num) - val.y;
				int num6 = Mathf.Clamp((int)((val.x + (float)(facing * num2) * 6f) / 3f), 0, wCells - 1);
				float num7 = (float)(int)slabH[lane2][num6] * 3f;
				float num8 = (float)(int)midHi[lane2][num6] * 3f;
				if ((num7 > 0f && num5 < num7 - 7f) || (num8 > 0f && num5 < num8 - 7f && num5 + 22f > (float)(int)midLo[lane2][num6] * 3f + 1f))
				{
					crashFlashT = 0.3f;
					return SwingHit.Wall;
				}
				s = sIn;
				h = num5;
				if (!CrateHit(lane2, val.x))
				{
					continue;
				}
				float num9 = Mathf.Sqrt(swingVx * swingVx + swingVy * swingVy);
				if (num9 > 90f)
				{
					swingVx *= 90f / num9;
					swingVy *= 90f / num9;
				}
				crashFlashT = 0.25f;
				return SwingHit.Crate;
			}
			return SwingHit.None;
		}

		private void DetachRope()
		{
			if (roping)
			{
				roping = false;
				vy = swingVy;
				speed = Mathf.Clamp(speed, -120f, 587.5f);
			}
		}

		private Vector2 MapPath(float sIn, float hIn, out int lane, out int facing, out bool inBend)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Seg seg;
			return MapPath(sIn, hIn, out lane, out facing, out inBend, out seg);
		}

		private Vector2 MapPath(float sIn, float hIn, out int lane, out int facing, out bool inBend, out Seg seg)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Repeat(sIn, loopLen);
			Seg seg2 = segs[segs.Count - 1];
			for (int i = 0; i < segs.Count; i++)
			{
				if (num < segs[i].s0 + segs[i].len)
				{
					seg2 = segs[i];
					break;
				}
			}
			seg = seg2;
			float num2 = num - seg2.s0;
			facing = seg2.dir;
			if (seg2.kind == SegKind.Straight)
			{
				lane = seg2.level;
				inBend = false;
				float num3 = seg2.xA + (float)seg2.dir * num2;
				return new Vector2(num3, FloorWorldY(lane, num3) + hIn);
			}
			lane = seg2.linkA;
			inBend = true;
			if (seg2.kind == SegKind.Arc)
			{
				float num4 = (seg2.up ? 1f : (-1f));
				float num5 = seg2.r1 * MathF.PI * 0.5f;
				if (num2 < num5)
				{
					float num6 = num2 / seg2.r1;
					return new Vector2(seg2.xA + (float)seg2.dir * seg2.r1 * Mathf.Sin(num6), seg2.yA + num4 * (seg2.r1 - seg2.r1 * Mathf.Cos(num6)) + hIn);
				}
				float num7 = (num2 - num5) / seg2.r2;
				return new Vector2(seg2.xB + (float)seg2.dir * seg2.r2 * Mathf.Cos(num7), seg2.yB - num4 * (seg2.r2 - seg2.r2 * Mathf.Sin(num7)) + hIn);
			}
			float num8 = seg2.r1 * MathF.PI * 0.5f;
			if (num2 < num8)
			{
				float num9 = num2 / seg2.r1;
				return new Vector2(seg2.xA - seg2.r1 * Mathf.Sin(num9), seg2.yA + seg2.r1 - seg2.r1 * Mathf.Cos(num9) + hIn);
			}
			if (num2 < num8 + seg2.vLen)
			{
				return new Vector2(seg2.xA - seg2.r1, seg2.yA + seg2.r1 + (num2 - num8) + hIn);
			}
			float num10 = (num2 - num8 - seg2.vLen) / seg2.r1;
			return new Vector2(seg2.xA - seg2.r1 * Mathf.Cos(num10), seg2.yB - seg2.r1 + seg2.r1 * Mathf.Sin(num10) + hIn);
		}

		private float FloorWorldY(int lane, float x)
		{
			float[] array = floorTab[lane];
			float num = (x - 1.5f) / 3f;
			int num2 = Mathf.Clamp(Mathf.FloorToInt(num), 0, wCells - 2);
			return Mathf.Lerp(array[num2], array[num2 + 1], Mathf.Clamp01(num - (float)num2));
		}

		private float CeilWorldY(int lane, float x)
		{
			return FloorWorldY(lane, x) + laneHPx;
		}

		private Vector2 PathDir(float sIn, out Seg leadSeg)
		{
			//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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			int lane;
			int facing;
			bool inBend;
			Vector2 val = MapPath(sIn - 1f, 0f, out lane, out facing, out inBend);
			Vector2 val2 = MapPath(sIn + 1f, 0f, out facing, out lane, out inBend, out leadSeg) - val;
			return ((Vector2)(ref val2)).normalized;
		}

		private void DeriveThemeShades()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_008e: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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)
			deepDark = ArcadeThemes.Scale(theme.deep, 0.75f);
			midDark = ArcadeThemes.Scale(theme.mid, 0.75f);
			slabDark = ArcadeThemes.Scale(theme.slab, 0.82f);
			tunnelBg = ArcadeThemes.Scale(theme.mid, 0.42f);
			dcDark = ArcadeThemes.Scale(theme.mid, 0.5f);
			dcMid = ArcadeThemes.Scale(theme.mid, 0.68f);
			dcAccent = ArcadeThemes.Scale(theme.cap, 0.62f);
		}

		private void AllocTrack()
		{
			floorTab = new float[10][];
			for (int i = 0; i < 10; i++)
			{
				floorTab[i] = new float[wCells];
			}
			ropeCol0 = new short[10];
			ropeCol1 = new short[10];
			rockLo = new short[wCells * 10];
			rockHi = new short[wCells * 10];
			rockN = new byte[wCells];
			featRow = new short[wCells * 10];
			featLevel = new sbyte[wCells * 10];
			featN = new byte[wCells];
			AllocDecor();
		}

		private int Rng(int maxExclusive)
		{
			return ArcadeRng.Next(ref rngState, maxExclusive);
		}

		private void BuildTrack(uint seed)
		{
			rngState = ((seed == 0) ? 1u : seed);
			theme = ArcadeThemes.RollTheme(ref rngState, ArcadeTheming.DestinationScene);
			DeriveThemeShades();
			speedLines.Clear();
			for (int i = 0; i < 64; i++)
			{
				if (TryBuildLayout(i >= 12))
				{
					return;
				}
			}
			ScorchedVoxelsPlugin.Log.LogError((object)"[ScorchedVoxels] race layout attempts exhausted; building the failsafe circuit");
			rngState = 1u;
			TryBuildLayout(flat: true);
		}

		private bool TryBuildLayout(bool flat)
		{
			segs.Clear();
			crates.Clear();
			ClearDecor();
			for (int i = 0; i < 10; i++)
			{
				Array.Clear(slabH[i], 0, wCells);
				Array.Clear(stalD[i], 0, wCells);
				Array.Clear(midLo[i], 0, wCells);
				Array.Clear(midHi[i], 0, wCells);
			}
			int num = (flat ? 4 : ((Rng(10) < 7) ? 4 : 6));
			float[] array = new float[num - 1];
			for (int j = 0; j < array.Length; j++)
			{
				array[j] = laneHPx + 44f + (float)Rng(113);
			}
			float num2 = 150f + (float)Rng(160);
			float num3 = num2 + (flat ? 150f : 720f);
			List<LevelPlan> list = new List<LevelPlan>();
			float num4 = num2;
			float num5 = 0f;
			for (int k = 0; k < num; k++)
			{
				int num6 = (((k & 1) == 0) ? 1 : (-1));
				if (k != num - 1)
				{
					float num7 = array[k];
					float num8 = Mathf.Round(num7 * 0.609f);
					float num11;
					if (num6 > 0)
					{
						float num9 = num4 + 700f;
						float num10 = ww - 10f - num8;
						if (num10 - num9 < 1f)
						{
							return false;
						}
						num11 = num9 + (float)Rng((int)(num10 - num9));
						if (k == 0)
						{
							num11 = Mathf.Max(num11, num4 + (num10 - num4) * 0.78f);
						}
					}
					else
					{
						float num12 = Mathf.Max(10f + num8, num3 + 24f + num8);
						float num13 = num4 - 700f;
						if (num13 - num12 < 1f)
						{
							return false;
						}
						num11 = num12 + (float)Rng((int)(num13 - num12));
					}
					LevelPlan levelPlan = new LevelPlan
					{
						level = k,
						dir = num6,
						x0 = num4,
						x1 = num11,
						y0 = num5
					};
					BuildLevelTiles(levelPlan, flat, flatOnly: false);
					list.Add(levelPlan);
					AddStraight(k, num4, num11, num6);
					float num14 = num7 - num8;
					AddRail(SegKind.Arc, num6, num11, levelPlan.yExit, num11 + (float)num6 * (num8 - num14), levelPlan.yExit - num7, num8, num14, up: false, k, k + 1);
					num4 = num11 + (float)num6 * (num8 - num14);
					num5 = levelPlan.yExit - num7;
					continue;
				}
				float num15 = 0f - num5;
				int num16 = 0;
				float num17 = num15;
				if (!flat && num15 >= 708f)
				{
					num16 = Mathf.Clamp(Mathf.RoundToInt(num15 / 700f), 1, 2);
					num17 = num15 / (float)(2 * num16 + 1);
					if (num17 > 430f && num16 < 2)
					{
						num16 = 2;
						num17 = num15 / 5f;
					}
				}
				bool flag = num16 == 0 || num17 > 430f || num17 < 236f;
				if (flag)
				{
					num16 = 0;
				}
				float[] array2 = new float[num16 * 2];
				for (int l = 0; l < array2.Length; l++)
				{
					array2[l] = 170f + (float)Rng(210);
				}
				float num18 = Mathf.Round(num17 * 0.609f);
				float num19 = num18 - (num17 - num18);
				float num20 = (flag ? num2 : ((num16 != 1) ? (num2 + num19 - array2[0] + array2[1] - array2[2] + array2[3]) : (num2 + num19 + array2[1] - array2[0])));
				if (num4 - num20 < 700f)
				{
					return false;
				}
				if (!flag && num20 < num18 + 32f)
				{
					return false;
				}
				LevelPlan levelPlan2 = new LevelPlan
				{
					level = k,
					dir = -1,
					x0 = num4,
					x1 = num20,
					y0 = num5
				};
				BuildLevelTiles(levelPlan2, flat, flatOnly: true);
				list.Add(levelPlan2);
				AddStraight(k, num4, num20, -1);
				if (flag)
				{
					float num21 = Mathf.Clamp(num2 - 46f, 60f, 84f + (float)Rng(29));
					if (num15 < 2f * num21 + 60f)
					{
						return false;
					}
					AddRail(SegKind.Shaft, -1, num2, num5, num2, 0f, num21, num21, up: true, k, 0);
					continue;
				}
				float num22 = num20;
				float num23 = num5;
				int num24 = num;
				for (int m = 0; m <= num16 * 2; m++)
				{
					bool flag2 = (m & 1) == 0;
					float num25 = ((m == num16 * 2) ? (0f - num23) : num17);
					float num26 = Mathf.Round(num25 * 0.609f);
					float num27 = num25 - num26;
					if (flag2 && num22 - num26 - 24f < 8f)
					{
						return false;
					}
					if (!flag2 && num22 + num26 + 24f > num3 - 24f)
					{
						return false;
					}
					int linkA = ((m == 0) ? k : (num24 - 1));
					int linkB = ((m != num16 * 2) ? num24 : 0);
					float num28 = (flag2 ? (num22 - (num26 - num27)) : (num22 + (num26 - num27)));
					AddRail(SegKind.Arc, (!flag2) ? 1 : (-1), num22, num23, num28, num23 + num25, num26, num27, up: true, linkA, linkB);
					num22 = num28;
					num23 += num25;
					if (m == num16 * 2)
					{
						break;
					}
					int num29 = (flag2 ? 1 : (-1));
					float num30 = num22 + (float)num29 * array2[m];
					if (num30 < 30f || num30 > num3 - 30f)
					{
						return false;
					}
					LevelPlan levelPlan3 = new LevelPlan
					{
						level = num24,
						dir = num29,
						x0 = num22,
						x1 = num30,
						y0 = num23
					};
					BuildLedge(levelPlan3);
					list.Add(levelPlan3);
					AddStraight(num24, num22, num30, num29);
					num24++;
					num22 = num30;
				}
				if (Mathf.Abs(num22 - num2) > 0.75f)
				{
					return false;
				}
			}
			BakeFloors(list);
			BakeSegments(list);
			if (!BakeSpans(list))
			{
				return false;
			}
			PlaceDecor(list);
			BakeDressing();
			startCol = (int)(num2 / 3f);
			return true;
		}

		private void AddStraight(int level, float x0, float x1, int dir)
		{
			segs.Add(new Seg
			{
				kind = SegKind.Straight,
				dir = dir,
				level = level,
				xA = x0,
				xB = x1
			});
		}

		private void AddRail(SegKind kind, int dir, float xA, float yA, float xB, float yB, float r1, float r2, bool up, int linkA, int linkB)
		{
			segs.Add(new Seg
			{
				kind = kind,
				dir = dir,
				xA = xA,
				yA = yA,
				xB = xB,
				yB = yB,
				r1 = r1,
				r2 = r2,
				up = up,
				vLen = ((kind == SegKind.Shaft) ? (yB - yA - 2f * r1) : 0f),
				boost = up,
				linkA = linkA,
				linkB = linkB
			});
		}

		private void BuildLevelTiles(LevelPlan lv, bool flat, bool flatOnly)
		{
			float num = Mathf.Abs(lv.x1 - lv.x0);
			float pos = 0f;
			float y = lv.y0;
			lv.cpT.Add(0f);
			lv.cpY.Add(y);
			EndTile((lv.level != 0) ? TileKind.Landing : TileKind.Start, (lv.level == 0) ? 240f : 110f, y);
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			while (num - pos > 430f)
			{
				float num2 = num - pos - 110f;
				int num3 = Rng(100);
				bool flag6 = !flat && !flatOnly;
				if (num3 < 14 && !flag && num2 >= 560f)
				{
					float len = Mathf.Min(560f + (float)Rng(360), num2);
					flag = true;
					TileFork(lv, pos, len);
					EndTile(TileKind.Fork, len, y);
				}
				else if (num3 < 27 && !flag2 && num2 >= 430f)
				{
					float len2 = Mathf.Min(430f + (float)Rng(240), num2);
					flag2 = true;
					TileBridge(lv, pos, len2);
					EndTile(TileKind.Bridge, len2, y);
				}
				else if (num3 < 40 && num2 >= 370f)
				{
					float len3 = Mathf.Min(370f + (float)Rng(180), num2);
					TileTerrace(lv, pos, len3);
					EndTile(TileKind.Terrace, len3, y);
				}
				else if (num3 < 53 && num2 >= 300f)
				{
					float len4 = Mathf.Min(300f + (float)Rng(160), num2);
					TileCrateAlley(lv, pos, len4);
					EndTile(TileKind.CrateAlley, len4, y);
				}
				else if (num3 < 66 && num2 >= 340f)
				{
					float len5 = Mathf.Min(340f + (float)Rng(180), num2);
					TilePinch(lv, pos, len5);
					EndTile(TileKind.Pinch, len5, y);
				}
				else if (flag6 && num3 < 76 && !flag3 && num2 >= 460f)
				{
					float num4 = Mathf.Min(460f + (float)Rng(300), num2);
					float num5 = Mathf.Min(0.09f * num4, 80f);
					flag3 = true;
					lv.tiles.Add(new TilePlan
					{
						kind = TileKind.Ridge,
						t0 = pos,
						t1 = pos + num4
					});
					lv.cpT.Add(pos + num4 * 0.5f);
					lv.cpY.Add(y + num5);
					crates.Add(new Crate
					{
						lane = lv.level,
						col = Mathf.Clamp(ColAt(lv, pos + num4 * 0.5f), 0, wCells - 7),
						baseY = 0f
					});
					pos += num4;
					lv.cpT.Add(pos);
					lv.cpY.Add(y);
				}
				else if (flag6 && num3 < 86 && !flag4 && num2 >= 320f && y - lv.y0 > -30f)
				{
					float num6 = Mathf.Min(320f + (float)Rng(150), num2);
					float num7 = (0f - (0.26f + (float)Rng(5) * 0.01f)) * num6;
					EndTile(TileKind.Dive, num6, y + num7);
				}
				else if (flag6 && num3 < 94 && !flag5 && num2 >= 300f && y - lv.y0 < 60f)
				{
					float num8 = Mathf.Min(300f + (float)Rng(120), num2);
					float num9 = (0.18f + (float)Rng(5) * 0.01f) * num8;
					flag5 = true;
					EndTile(TileKind.Summit, num8, y + num9);
				}
				else
				{
					float len6 = Mathf.Min(200f + (float)Rng(120), num2);
					TileSprint(lv, pos, len6);
					EndTile(TileKind.Sprint, len6, y);
				}
			}
			EndTile(TileKind.Sprint, num - pos, y);
			lv.yExit = y;
			void EndTile(TileKind kind, float num10, float yEnd)
			{
				lv.tiles.Add(new TilePlan
				{
					kind = kind,
					t0 = pos,
					t1 = pos + num10
				});
				pos += num10;
				y = yEnd;
				lv.cpT.Add(pos);
				lv.cpY.Add(y);
			}
		}

		private void BuildLedge(LevelPlan lv)
		{
			float num = Mathf.Abs(lv.x1 - lv.x0);
			lv.cpT.Add(0f);
			lv.cpY.Add(lv.y0);
			lv.tiles.Add(new TilePlan
			{
				kind = TileKind.Sprint,
				t0 = 0f,
				t1 = num
			});
			lv.cpT.Add(num);
			lv.cpY.Add(lv.y0);
			lv.yExit = lv.y0;
			TileSprint(lv, 0f, num);
		}

		private int ColAt(LevelPlan lv, float t)
		{
			return (int)((lv.x0 + (float)lv.dir * t) / 3f);
		}

		private void TileCols(LevelPlan lv, float t0, float len, out int c0, out int c1)
		{
			int num = ColAt(lv, t0);
			int num2 = ColAt(lv, t0 + len);
			c0 = Mathf.Clamp(Mathf.Min(num, num2) + 22, 0, wCells - 1);
			c1 = Mathf.Clamp(Mathf.Max(num, num2) - 22, 0, wCells - 1);
		}

		private void TileFork(LevelPlan lv, float t0, float len)
		{
			TileCols(lv, t0, len, out var c, out var c2);
			int level = lv.level;
			int num = 66;
			int num2 = ((c2 - c < 240) ? 1 : 2);
			int num3 = (c2 - c - (num2 - 1) * 64) / num2;
			for (int i = 0; i < num2; i++)
			{
				int num4 = c + i * (num3 + 64);
				int num5 = Mathf.Min(num4 + num3, c2);
				for (int j = num4; j < num5; j++)
				{
					int num6 = Mathf.Min((lv.dir > 0) ? (j - num4) : (num5 - 1 - j), num) / 3;
					midLo[level][j] = (byte)(8 + num6);
					midHi[level][j] = (byte)(12 + num6);
				}
			}
			int num7 = 34;
			int num9;
			for (int k = c; k < c2; k += num9 + 75 + Rng(70))
			{
				bool flag = midHi[level][Mathf.Min(k, wCells - 1)] > 0;
				bool flag2 = false;
				for (int l = k - 10; l <= k + 70; l += 5)
				{
					int num8 = Mathf.Clamp(l, 0, wCells - 1);
					bool flag3 = midHi[level][num8] > 0;
					if (flag3 != flag || (flag3 && midHi[level][num8] < num7))
					{
						flag2 = true;
						break;
					}
				}
				num9 = 10;
				if (flag2)
				{
					continue;
				}
				if (flag && Rng(2) == 0)
				{
					if (Rng(100) < 55)
					{
						int num10 = 1 + Rng(2);
						num9 = num10 * 10;
						for (int m = 0; m < num10; m++)
						{
							if (k + m * 10 + 6 < c2)
							{
								crates.Add(new Crate
								{
									lane = level,
									col = k + m * 10,
									baseY = 0f
								});
							}
						}
					}
					else
					{
						int num11 = 7 + Rng(6);
						int num12 = 4 + Rng(3);
						for (int n = 0; n < num11 && k + n < c2; n++)
						{
							slabH[level][k + n] = (byte)num12;
						}
						num9 = num11;
					}
				}
				else
				{
					if (!flag)
					{
						continue;
					}
					int num13 = Rng(100);
					if (num13 < 40)
					{
						int num14 = 1 + Rng(2);
						num9 = num14 * 10;
						for (int num15 = 0; num15 < num14; num15++)
						{
							if (k + num15 * 10 + 6 < c2)
							{
								crates.Add(new Crate
								{
									lane = level,
									col = k + num15 * 10,
									baseY = 102f
								});
							}
						}
						continue;
					}
					if (num13 < 70)
					{
						int num16 = 7 + Rng(6);
						int num17 = 4 + Rng(3);
						for (int num18 = 0; num18 < num16 && k + num18 < c2; num18++)
						{
							if (midHi[level][k + num18] > 0)
							{
								midHi[level][k + num18] += (byte)num17;
							}
						}
						num9 = num16;
						continue;
					}
					int num19 = 1 + Rng(2);
					num9 = num19 * 9;
					for (int num20 = 0; num20 < num19; num20++)
					{
						for (int num21 = 0; num21 < 5 && k + num20 * 9 + num21 < c2; num21++)
						{
							stalD[level][k + num20 * 9 + num21] = (byte)(12 + Rng(9));
						}
					}
				}
			}
		}

		private void TileBridge(LevelPlan lv, float t0, float len)
		{
			TileCols(lv, t0, len, out var c, out var c2);
			if (c2 - c < 90)
			{
				return;
			}
			int level = lv.level;
			int num = 22 + Rng(5);
			for (int i = c; i <= c2 && i < wCells; i++)
			{
				if (i >= 0)
				{
					int num2 = ((lv.dir > 0) ? (i - c) : (c2 - i));
					int num3 = Mathf.Min(8 + num2 / 3, num);
					midLo[level][i] = (byte)num3;
					midHi[level][i] = (byte)(num3 + 3);
				}
			}
			int num4 = (c + c2) / 2;
			crates.Add(new Crate
			{
				lane = level,
				col = num4,
				baseY = (float)(num + 3) * 3f
			});
			for (int j = 0; j < 1 + Rng(2); j++)
			{
				int num5 = c + 20 + Rng(Mathf.Max(c2 - c - 46, 1));
				if (Mathf.Abs(num5 - num4) > 12)
				{
					crates.Add(new Crate
					{
						lane = level,
						col = num5,
						baseY = 0f
					});
				}
			}
		}

		private void TileTerrace(LevelPlan lv, float t0, float len)
		{
			TileCols(lv, t0, len, out var c, out var c2);
			if (c2 - c < 60)
			{
				return;
			}
			int level = lv.level;
			int num = 2 + Rng(2);
			int num2 = (c + c2) / 2;
			int num3 = 10 + Rng(5);
			int num4 = Mathf.Min((c2 - c) / 2 - 4, num * num3 + 8);
			int num5 = num * 4;
			for (int i = num2 - num4; i <= num2 + num4 && i < wCells; i++)
			{
				if (i >= 0)
				{
					int num6 = Mathf.Min(((num4 - Mathf.Abs(i - num2)) / num3 + 1) * 4, num5);
					slabH[level][i] = (byte)num6;
				}
			}
			if (Rng(2) == 0)
			{
				crates.Add(new Crate
				{
					lane = level,
					col = num2 - 3,
					baseY = (float)num5 * 3f
				});
			}
		}

		private void TileCrateAlley(LevelPlan lv, float t0, float len)
		{
			TileCols(lv, t0, len, out var c, out var c2);
			int num;
			for (int i = c + 4; i < c2 - 12; i += num * 10 + 75 + Rng(50))
			{
				num = 1 + Rng(3);
				for (int j = 0; j < num; j++)
				{
					if (i + j * 10 + 6 < c2)
					{
						crates.Add(new Crate
						{
							lane = lv.level,
							col = i + j * 10,
							baseY = 0f
						});
					}
				}
			}
		}

		private void TilePinch(LevelPlan lv, float t0, float len)
		{
			TileCols(lv, t0, len, out var c, out var c2);
			int level = lv.level;
			int num = c + 4;
			while (num < c2 - 16)
			{
				if (Rng(100) < 70)
				{
					int num2 = 8 + Rng(7);
					int num3 = 4 + Rng(5);
					for (int i = 0; i < num2 && num + i < c2; i++)
					{
						slabH[level][num + i] = (byte)num3;
					}
					if (Rng(100) < 55)
					{
						int num4 = 11 + Rng(4);
						int num5 = 64 - num3 - num4;
						for (int j = 1; j + 1 < num2 && num + j < c2; j++)
						{
							stalD[level][num + j] = (byte)Mathf.Max(num5, 0);
						}
					}
					num += num2 + 75 + Rng(45);
					continue;
				}
				int num6 = 1 + Rng(2);
				for (int k = 0; k < num6; k++)
				{
					for (int l = 0; l < 5 && num + k * 9 + l < c2; l++)
					{
						stalD[level][num + k * 9 + l] = (byte)(44 + Rng(7));
					}
				}
				num += num6 * 9 + 75 + Rng(45);
			}
		}

		private void TileSprint(LevelPlan lv, float t0, float len)
		{
			if (!(len < 260f) && Rng(100) >= 45)
			{
				TileCols(lv, t0, len, out var c, out var c2);
				int num = c + (c2 - c) / 2;
				if (num + 6 < c2)
				{
					crates.Add(new Crate
					{
						lane = lv.level,
						col = num,
						baseY = 0f
					});
				}
			}
		}

		private void BakeFloors(List<LevelPlan> lvls)
		{
			foreach (LevelPlan lvl in lvls)
			{
				float num = Mathf.Abs(lvl.x1 - lvl.x0);
				float num2 = 5f + (float)Rng(8);
				float num3 = 3f + (float)Rng(5);
				float num4 = MathF.PI * 2f / (700f + (float)Rng(400));
				float num5 = MathF.PI * 2f / (320f + (float)Rng(220));
				float num6 = (float)Rng(628) * 0.01f;
				float num7 = (float)Rng(628) * 0.01f;
				float[] array = floorTab[lvl.level];
				for (int i = 0; i < wCells; i++)
				{
					float num8 = (float)i * 3f + 1.5f;
					float num9 = Mathf.Clamp((lvl.dir > 0) ? (num8 - lvl.x0) : (lvl.x0 - num8), 0f, num);
					int j;
					for (j = 1; j < lvl.cpT.Count - 1 && lvl.cpT[j] < num9; j++)
					{
					}
					float num10 = lvl.cpT[j - 1];
					float num11 = lvl.cpT[j];
					float num12 = ((num11 > num10) ? Mathf.SmoothStep(lvl.cpY[j - 1], lvl.cpY[j], (num9 - num10) / (num11 - num10)) : lvl.cpY[j]);
					float num13 = Mathf.Clamp01(Mathf.Min(num9, num - num9) / 140f);
					num13 *= num13 * (3f - 2f * num13);
					foreach (TilePlan tile in lvl.tiles)
					{
						if (tile.kind == TileKind.Ridge || tile.kind == TileKind.Dive || tile.kind == TileKind.Summit)
						{
							float num14 = Mathf.Max(tile.t0 - num9, num9 - tile.t1);
							num13 = Mathf.Min(num13, Mathf.Clamp01(num14 / 60f));
						}
					}
					array[i] = num12 + num13 * (num2 * Mathf.Sin(num8 * num4 + num6) + num3 * Mathf.Sin(num8 * num5 + num7));
				}
			}
		}

		private void BakeSegments(List<LevelPlan> lvls)
		{
			float num = float.MaxValue;
			float num2 = float.MinValue;
			foreach (LevelPlan lvl in lvls)
			{
				int num3 = Mathf.Max((int)(Mathf.Min(lvl.x0, lvl.x1) / 3f), 0);
				int num4 = Mathf.Min((int)(Mathf.Max(lvl.x0, lvl.x1) / 3f), wCells - 1);
				for (int i = num3; i <= num4; i++)
				{
					num = Mathf.Min(num, floorTab[lvl.level][i]);
					num2 = Mathf.Max(num2, floorTab[lvl.level][i]);
				}
			}
			float num5 = 90f - num;
			worldHpx = num2 + num5 + laneHPx + 90f;
			worldRows = Mathf.CeilToInt(worldHpx / 3f);
			foreach (LevelPlan lvl2 in lvls)
			{
				lvl2.y0 += num5;
				lvl2.yExit += num5;
				float[] array = floorTab[lvl2.level];
				int num6 = Mathf.Max((int)(Mathf.Min(lvl2.x0, lvl2.x1) / 3f), 0);
				int num7 = Mathf.Min((int)(Mathf.Max(lvl2.x0, lvl2.x1) / 3f), wCells - 1);
				for (int j = num6; j <= num7; j++)
				{
					array[j] += num5;
				}
				for (int k = 0; k < num6; k++)
				{
					array[k] = array[num6];
				}
				for (int l = num7 + 1; l < wCells; l++)
				{
					array[l] = array[num7];
				}
				ropeCol0[lvl2.level] = (short)num6;
				ropeCol1[lvl2.level] = (short)num7;
			}
			for (int m = 0; m < segs.Count; m++)
			{
				Seg seg = segs[m];
				if (seg.kind != SegKind.Straight)
				{
					continue;
				}
				Seg seg2 = segs[(m + 1) % segs.Count];
				if (seg2.kind != SegKind.Straight && !seg2.up)
				{
					if (seg.dir > 0)
					{
						ropeCol1[seg.level] = (short)(wCells - 1);
					}
					else
					{
						ropeCol0[seg.level] = 0;
					}
				}
			}
			float num8 = 0f;
			foreach (Seg seg3 in segs)
			{
				seg3.s0 = num8;
				if (seg3.kind == SegKind.Straight)
				{
					LevelPlan levelPlan = lvls[seg3.level];
					seg3.yA = levelPlan.y0;
					seg3.yB = levelPlan.yExit;
					seg3.len = Mathf.Abs(seg3.xB - seg3.xA);
				}
				else
				{
					seg3.yA += num5;
					seg3.yB += num5;
					seg3.len = ((seg3.kind == SegKind.Shaft) ? (seg3.r1 * MathF.PI + seg3.vLen) : ((seg3.r1 + seg3.r2) * MathF.PI * 0.5f));
				}
				num8 += seg3.len;
			}
			loopLen = num8;
		}

		private bool BakeSpans(List<LevelPlan> lvls)
		{
			boostBoxes.Clear();
			int num = 0;
			int[] array = new int[12];
			int[] array2 = new int[12];
			short[] array3 = new short[12];
			short[] array4 = new short[12];
			sbyte[] array5 = new sbyte[12];
			sbyte[] array6 = new sbyte[12];
			foreach (Seg seg in segs)
			{
				if (seg.kind == SegKind.Straight)
				{
					continue;
				}
				float num2 = Mathf.Min(seg.yA, seg.yB);
				float num3 = Mathf.Max(seg.yA, seg.yB) + laneHPx;
				float num4;
				float num5;
				if (seg.kind == SegKind.Arc)
				{
					if (seg.dir > 0)
					{
						num4 = Mathf.Min(seg.xA, seg.xB) - 6f;
						num5 = seg.xA + seg.r1 + 24f;
					}
					else
					{
						num4 = seg.xA - seg.r1 - 24f;
						num5 = Mathf.Max(seg.xA, seg.xB) + 6f;
					}
				}
				else
				{
					num4 = seg.xA - seg.r1 - 36f;
					num5 = seg.xA + 16f;
				}
				array[num] = (int)(num4 / 3f);
				array2[num] = (int)(num5 / 3f);
				array3[num] = (short)Mathf.RoundToInt(num2 / 3f);
				array4[num] = (short)Mathf.RoundToInt(num3 / 3f);
				array5[num] = (sbyte)seg.linkA;
				array6[num] = (sbyte)seg.linkB;
				if (seg.boost)
				{
					boostBoxes.Add((array[num], array2[num], array3[num], array4[num]));
				}
				num++;
			}
			short[] array7 = new short[22];
			short[] array8 = new short[22];
			sbyte[] array9 = new sbyte[22];
			for (int i = 0; i < wCells; i++)
			{
				int num6 = 0;
				foreach (LevelPlan lvl in lvls)
				{
					int num7 = (int)(Mathf.Min(lvl.x0, lvl.x1) / 3f);
					int num8 = (int)(Mathf.Max(lvl.x0, lvl.x1) / 3f);
					if (i >= num7 && i <= num8)
					{
						array7[num6] = (short)Mathf.RoundToInt(floorTab[lvl.level][i] / 3f);
						array8[num6] = (short)(array7[num6] + 64);
						array9[num6] = (sbyte)lvl.level;
						num6++;
					}
				}
				for (int j = 0; j < num; j++)
				{
					if (i >= array[j] && i <= array2[j])
					{
						array7[num6] = array3[j];
						array8[num6] = array4[j];
						array9[num6] = (sbyte)(-(j + 2));
						num6++;
					}
				}
				for (int k = 1; k < num6; k++)
				{
					int num9 = k;
					while (num9 > 0 && array7[num9] < array7[num9 - 1])
					{
						ref short reference = ref array7[num9];
						ref short reference2 = ref array7[num9 - 1];
						short num10 = array7[num9 - 1];
						short num11 = array7[num9];
						reference = num10;
						reference2 = num11;
						reference = ref array8[num9];
						ref short reference3 = ref array8[num9 - 1];
						num11 = array8[num9 - 1];
						num10 = array8[num9];
						reference = num11;
						reference3 = num10;
						ref sbyte reference4 = ref array9[num9];
						ref sbyte reference5 = ref array9[num9 - 1];
						sbyte b = array9[num9 - 1];
						sbyte b2 = array9[num9];
						reference4 = b;
						reference5 = b2;
						num9--;
					}
				}
				int num12 = 0;
				featN[i] = 0;
				short num13 = 0;
				short num14 = -1;
				int num15 = 0;
				bool flag = false;
				for (int l = 0; l < num6; l++)
				{
					if (array9[l] >= 0)
					{
						int num16 = i * 10 + featN[i];
						featRow[num16] = array7[l];
						featLevel[num16] = array9[l];
						featN[i]++;
					}
					if (flag && array7[l] < num14 + 4)
					{
						bool flag2;
						if (array9[l] < -1)
						{
							int num17 = -array9[l] - 2;
							flag2 = true;
							for (int m = num15; m < l; m++)
							{
								if (array9[m] < -1 || (array5[num17] != array9[m] && array6[num17] != array9[m]))
								{
									flag2 = false;
								}
							}
						}
						else
						{
							flag2 = false;
							for (int n = num15; n < l; n++)
							{
								if (array9[n] < -1 && (array5[-array9[n] - 2] == array9[l] || array6[-array9[n] - 2] == array9[l]))
								{
									flag2 = true;
								}
							}
						}
						if (!flag2)
						{
							return false;
						}
						num14 = (short)Mathf.Max((int)num14, (int)array8[l]);
						continue;
					}
					if (flag)
					{
						if (num12 == 10)
						{
							return false;
						}
						rockLo[i * 10 + num12] = num13;
						rockHi[i * 10 + num12] = num14;
						num12++;
					}
					flag = true;
					num15 = l;
					num13 = array7[l];
					num14 = array8[l];
				}
				if (flag)
				{
					if (num12 == 10)
					{
						return false;
					}
					rockLo[i * 10 + num12] = num13;
					rockHi[i * 10 + num12] = num14;
					num12++;
				}
				rockN[i] = (byte)num12;
				for (int num18 = 0; num18 < num12; num18++)
				{
					if (rockLo[i * 10 + num18] < 8)
					{
						return false;
					}
					if (rockHi[i * 10 + num18] > worldRows - 8)
					{
						return false;
					}
				}
			}
			return true;
		}
	}
	internal sealed class RunnerFieldView
	{
		public const float CellPx = 3f;

		public const float PlayerScale = 3f;

		public const float CritterScale = 2.5f;

		public const float DroneScale = 2f;

		public const float GroundPx = 18f;

		private static readonly Color GrayedOut = new Color(0.6f, 0.6f, 0.6f, 0.8f);

		public readonly float W;

		public readonly float H;

		private readonly RectTransform rect;

		private readonly PixelSurface surface;

		private readonly Image player;

		private readonly RectTransform playerRect;

		private readonly Image[] obstacles;

		private readonly CommandoSprites.Critter[] slotKinds;

		private int lastScroll = int.MinValue;

		public float PlayerX => (0f - W) * 0.5f + W * 0.18f;

		public RunnerFieldView(string name, RectTransform parent, float designW, float designH, int obstacleSlots)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0049: 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_0092: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			W = designW;
			H = designH;
			GameObject val = new GameObject(name);
			val.transform.SetParent((Transform)(object)parent, false);
			rect = val.AddComponent<RectTransform>();
			rect.sizeDelta = new Vector2(designW, designH);
			surface = new PixelSurface("ground", (Transform)(object)rect, Mathf.CeilToInt(designW / 3f), Mathf.CeilToInt(designH / 3f), 3f);
			GameObject val2 = new GameObject("player");
			val2.transform.SetParent((Transform)(object)rect, false);
			player = val2.AddComponent<Image>();
			((Graphic)player).raycastTarget = false;
			playerRect = ((Graphic)player).rectTransform;
			playerRect.pivot = new Vector2(0.5f, 0f);
			playerRect.sizeDelta = CommandoSprites.CommandoSize * 3f;
			obstacles = (Image[])(object)new Image[obstacleSlots];
			slotKinds = new CommandoSprites.Critter[obstacleSlots];
			for (int i = 0; i < obstacleSlots; i++)
			{
				GameObject val3 = new GameObject($"critter{i}");
				val3.transform.SetParent((Transform)(object)rect, false);
				obstacles[i] = val3.AddComponent<Image>();
				((Graphic)obstacles[i]).raycastTarget = false;
				((Graphic)obstacles[i]).rectTransform.pivot = new Vector2(0.5f, 0f);
				val3.SetActive(false);
				slotKinds[i] = (CommandoSprites.Critter)(-1);
			}
		}

		public void SetScale(float s)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			((Transform)rect).localScale = new Vector3(s, s, 1f);
		}

		public void SetPlayer(float x, float y, int colorway, float spriteClock, bool ducking, bool grayed)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			playerRect.anchoredPosition = new Vector2(x, y);
			player.sprite = CommandoSprites.CommandoFrame(colorway, spriteClock);
			((Transform)playerRect).localScale = new Vector3(1f, ducking ? 0.55f : 1f, 1f);
			((Graphic)player).color = (grayed ? GrayedOut : Color.white);
		}

		public void SetObstacle(int i, CommandoSprites.Critter kind, float x, float y, float spriteClock)
		{
			//IL_0073: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			Image val = obstacles[i];
			if (!((Component)val).gameObject.activeSelf)
			{
				((Component)val).gameObject.SetActive(true);
			}
			val.sprite = CommandoSprites.CritterFrame(kind, spriteClock);
			if (slotKinds[i] != kind)
			{
				slotKinds[i] = kind;
				((Graphic)val).rectTransform.sizeDelta = CommandoSprites.CritterSize(kind) * ((kind == CommandoSprites.Critter.Drone) ? 2f : 2.5f);
			}
			((Graphic)val).rectTransform.anchoredPosition = new Vector2(x, y);
		}

		public void HideObstacle(int i)
		{
			if (((Component)obstacles[i]).gameObject.activeSelf)
			{
				((Component)obstacles[i]).gameObject.SetActive(false);
			}
		}

		public void DrawGround(float scrollPx)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			int num = (int)(scrollPx / 3f);
			if (num == lastScroll)
			{
				return;
			}
			lastScroll = num;
			surface.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			int num2 = 6;
			Color32 c = default(Color32);
			((Color32)(ref c))..ctor((byte)60, (byte)48, (byte)38, byte.MaxValue);
			Color32 c2 = default(Color32);
			((Color32)(ref c2))..ctor((byte)38, (byte)30, (byte)24, byte.MaxValue);
			surface.FillRect(0, num2 - 2, surface.W, 2, c);
			surface.FillRect(0, 0, surface.W, num2 - 2, c2);
			Color32 c3 = default(Color32);
			((Color32)(ref c3))..ctor((byte)84, (byte)68, (byte)52, byte.MaxValue);
			for (int i = 0; i < surface.W; i++)
			{
				if ((i + num) % 14 < 3)
				{
					surface.Set(i, num2 - 3 - (i + num) % 3, c3);
				}
			}
		}

		public void Flush()
		{
			surface.Flush();
		}

		public void Destroy()
		{
			surface.Destroy();
		}
	}
	internal class RunnerGame : IMiniGame
	{
		private enum Mode
		{
			Ready,
			Running,
			Dead
		}

		private class Obstacle
		{
			public CommandoSprites.Critter kind;

			public bool active;

			public float x;

			public float extraSpeed;

			public float animT;

			public float bobPhase;
		}

		private const float DroneBase = 34f;

		private const float DroneAmp = 10f;

		private const float DroneWave = 0.045f;

		private const float MinGapSeconds = 0.55f;

		private const float GroundPx = 18f;

		private const float Gravity = 1500f;

		private const float JumpV = 540f;

		private const float FastFall = 2400f;

		private const float StartSpeed = 160f;

		private const float MaxSpeed = 430f;

		private const float SpeedRamp = 4.5f;

		private const float RestartLockoutSeconds = 0.7f;

		private const float JumpBufferSeconds = 0.15f;

		private ArcadeContext ctx;

		private RunnerFieldView view;

		private readonly List<Obstacle> pool = new List<Obstacle>();

		private UiKit.Label scoreLabel;

		private UiKit.Label bestLabel;

		private UiKit.Label message;

		private Random rng;

		private string profileKey;

		private uint ownerNetId;

		private float nextSnapshotAt;

		private float diedAt;

		private float jumpBufferedUntil;

		private int sessionBest;

		private readonly ArcadeSnapshotMessage snapshotMsg = new ArcadeSnapshotMessage();

		private readonly byte[] obKindBuf = new byte[8];

		private readonly byte[] obXBuf = new byte[8];

		private Mode mode;

		private int colorway;

		private float dist;

		private float speed;

		private float playerY;

		private float playerVy;

		private bool ducking;

		private float animT;

		private float nextSpawnAt;

		private float groundScroll;

		private int lastScore = -1;

		internal static float DroneFlightY(float x, float bobPhase)
		{
			return 34f + 10f * Mathf.Sin(x * 0.045f + bobPhase);
		}

		public void Start(ArcadeContext c)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			ctx = c;
			rng = new Random((int)ctx.seed ^ Environment.TickCount);
			colorway = ArcadeLocal.PreferredColorway();
			profileKey = ArcadeLocal.ProfileKey();
			ownerNetId = ArcadeLocal.NetId();
			sessionBest = UserLifetimeStats.RunnerBest(profileKey);
			view = new RunnerFieldView("runnerField", ctx.panel, ctx.width, ctx.height, 6);
			for (int i = 0; i < 6; i++)
			{
				pool.Add(new Obstacle());
			}
			scoreLabel = UiKit.CreateLabel("score", (Transform)(object)ctx.panel, 15f, UiKit.TextPale, (TextAnchor)5);
			scoreLabel.Rect.sizeDelta = new Vector2(90f, 20f);
			scoreLabel.Rect.anchoredPosition = new Vector2(ctx.width * 0.5f - 51f, ctx.height * 0.5f - 14f);
			bestLabel = UiKit.CreateLabel("best", (Transform)(object)ctx.panel, 12f, UiKit.TextDim, (TextAnchor)3);
			bestLabel.Rect.sizeDelta = new Vector2(120f, 18f);
			bestLabel.Rect.anchoredPosition = new Vector2((0f - ctx.width) * 0.5f + 66f, ctx.height * 0.5f - 13f);
			message = UiKit.CreateLabel("msg", (Transform)(object)ctx.panel, 14f, UiKit.Gold, (TextAnchor)4);
			message.Rect.sizeDelta = new Vector2(ctx.width - 20f, 22f);
			message.Rect.anchoredPosition = new Vector2(0f, 14f);
			Reset();
			mode = Mode.Ready;
			message.Text = "SPACE / CLICK to run";
		}

		private void Reset()
		{
			colorway = ArcadeLocal.PreferredColorway();
			dist = 0f;
			speed = 160f;
			playerY = 0f;
			playerVy = 0f;
			ducking = false;
			animT = 0f;
			groundScroll = 0f;
			nextSpawnAt = 260f;
			jumpBufferedUntil = 0f;
			for (int i = 0; i < pool.Count; i++)
			{
				pool[i].active = false;
				view.HideObstacle(i);
			}
			view.SetPlayer(view.PlayerX, (0f - ctx.height) * 0.5f + 18f, colorway, 0f, ducking: false, grayed: false);
			mode = Mode.Running;
			message.Text = "";
		}

		public void Tick(float dt)
		{
			switch (mode)
			{
			case Mode.Ready:
				if (ArcadeInput.ActionDown)
				{
					Reset();
				}
				break;
			case Mode.Dead:
				if (Time.unscaledTime - diedAt >= 0.7f && ArcadeInput.ActionDown)
				{
					Reset();
				}
				break;
			case Mode.Running:
				Step(dt);
				break;
			}
			view.DrawGround(groundScroll);
			view.Flush();
			MaybeBroadcast();
		}

		private void MaybeBroadcast()
		{
			if (ownerNetId == 0 || NetworkUser.readOnlyInstancesList.Count <= 1 || (!NetworkServer.active && !NetworkClient.active) || mode == Mode.Ready || (mode == Mode.Dead && Time.unscaledTime - diedAt > 3f) || Time.unscaledTime < nextSnapshotAt)
			{
				return;
			}
			nextSnapshotAt = Time.unscaledTime + 1f / 30f;
			int num = 0;
			foreach (Obstacle item in pool)
			{
				if (item.active && num < obKindBuf.Length)
				{
					obKindBuf[num] = (byte)item.kind;
					obXBuf[num] = (byte)Mathf.Clamp((item.x + ctx.width * 0.5f) / ctx.width * 255f, 0f, 255f);
					num++;
				}
			}
			byte state = (byte)((ducking ? 1u : 0u) | (uint)((mode == Mode.Dead) ? 2 : 0));
			snapshotMsg.Set(ownerNetId, (byte)colorway, (ushort)Mathf.Clamp(Score(), 0, 65535), state, (byte)Mathf.Clamp(playerY, 0f, 255f), (byte)Mathf.Clamp(speed * 0.5f, 0f, 255f), obKindBuf, obXBuf, num);
			if (NetworkServer.active)
			{
				NetMessageExtensions.Send((INetMessage)(object)snapshotMsg, (NetworkDestination)1);
			}
			else
			{
				NetMessageExtensions.Send((INetMessage)(object)snapshotMsg, (NetworkDestination)2);
			}
		}

		private void Step(float dt)
		{
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			dist += speed * dt;
			speed = Mathf.Min(430f, speed + 4.5f * dt);
			groundScroll += speed * dt;
			bool flag = playerY <= 0f;
			if (ArcadeInput.ActionDown)
			{
				jumpBufferedUntil = Time.unscaledTime + 0.15f;
			}
			if (flag && Time.unscaledTime <= jumpBufferedUntil)
			{
				jumpBufferedUntil = 0f;
				playerVy = 540f;
			}
			ducking = ArcadeInput.DuckHeld && flag;
			if (ArcadeInput.DuckHeld && !flag)
			{
				playerVy -= 2400f * dt;
			}
			playerVy -= 1500f * dt;
			playerY = Mathf.Max(0f, playerY + playerVy * dt);
			if (playerY <= 0f)
			{
				playerVy = Mathf.Max(playerVy, 0f);
			}
			if (flag)
			{
				animT += dt * (speed / 160f);
			}
			float playerX = view.PlayerX;
			float num = (0f - ctx.height) * 0.5f + 18f + playerY;
			view.SetPlayer(playerX, num, colorway, flag ? animT : 0.06f, ducking, grayed: false);
			if (dist >= nextSpawnAt)
			{
				Spawn();
			}
			Vector2 val = CommandoSprites.CommandoSize * 3f;
			float num2 = (ducking ? 0.55f : 1f) * val.y;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(playerX - val.x * 0.3f, num, val.x * 0.6f, num2 * 0.85f);
			for (int i = 0; i < pool.Count; i++)
			{
				Obstacle obstacle = pool[i];
				if (!obstacle.active)
				{
					continue;
				}
				obstacle.x -= (speed + obstacle.extraSpeed) * dt;
				obstacle.animT += dt;
				bool flag2 = obstacle.kind == CommandoSprites.Critter.Drone;
				float num3 = (0f - ctx.height) * 0.5f + 18f;
				if (flag2)
				{
					num3 += DroneFlightY(obstacle.x, obstacle.bobPhase);
				}
				Vector2 val3 = CommandoSprites.CritterSize(obstacle.kind) * (flag2 ? 2f : 2.5f);
				if (obstacle.x < (0f - ctx.width) * 0.5f - val3.x)
				{
					obstacle.active = false;
					view.HideObstacle(i);
					continue;
				}
				view.SetObstacle(i, obstacle.kind, obstacle.x, num3, obstacle.animT);
				float num4 = (speed + obstacle.extraSpeed) * dt;
				Rect val4 = (flag2 ? new Rect(obstacle.x - val3.x * 0.35f, num3 - 2f, val3.x * 0.7f + num4, val3.y * 0.8f) : new Rect(obstacle.x - val3.x * 0.35f, num3 + val3.y * 0.08f, val3.x * 0.7f + num4, val3.y * 0.8f));
				if (((Rect)(ref val2)).Overlaps(val4))
				{
					Die();
					return;
				}
			}
			int num5 = Score();
			if (num5 != lastScore)
			{
				lastScore = num5;
				scoreLabel.Text = num5.ToString();
				bestLabel.Text = $"best {Mathf.Max(sessionBest, num5)}";
			}
		}

		private int Score()
		{
			return (int)(dist / 12f);
		}

		private void Spawn()
		{
			Obstacle obstacle = null;
			foreach (Obstacle item in pool)
			{
				if (!item.active)
				{
					obstacle = item;
					break;
				}
			}
			if (obstacle == null)
			{
				return;
			}
			double num = rng.NextDouble();
			obstacle.kind = ((!(num < 0.4)) ? ((num < 0.58) ? CommandoSprites.Critter.Child : ((num < 0.72) ? CommandoSprites.Critter.Golem : CommandoSprites.Critter.Drone)) : CommandoSprites.Critter.Lemurian);
			obstacle.extraSpeed = ((obstacle.kind == CommandoSprites.Critter.Child) ? 70f : ((obstacle.kind == CommandoSprites.Critter.Drone) ? 50f : 0f));
			Obstacle obstacle2 = null;
			foreach (Obstacle item2 in pool)
			{
				if (item2.active && (obstacle2 == null || item2.x > obstacle2.x))
				{
					obstacle2 = item2;
				}
			}
			if (obstacle2 != null && obstacle.extraSpeed > obstacle2.extraSpeed)
			{
				obstacle.extraSpeed = obstacle2.extraSpeed;
			}
			obstacle.bobPhase = (float)(rng.NextDouble() * 6.28);
			obstacle.animT = (float)(rng.NextDouble() * 2.0);
			obstacle.x = ctx.width * 0.5f + 30f;
			obstacle.active = true;
			float num2 = 0.55f * (0.9f + (float)rng.NextDouble() * 0.8f);
			if (obstacle.kind == CommandoSprites.Critter.Golem)
			{
				num2 += 0.15f;
			}
			nextSpawnAt = dist + 170f + speed * num2;
		}

		private void Die()
		{
			mode = Mode.Dead;
			diedAt = Time.unscaledTime;
			int num = Score();
			if (num > sessionBest)
			{
				sessionBest = num;
			}
			UserLifetimeStats.ReportRunnerScore(profileKey, num);
			message.Text = $"CAUGHT at {num} — SPACE to retry";
			bestLabel.Text = $"best {sessionBest}";
		}

		public void End()
		{
			int num = Score();
			if (num > sessionBest)
			{
				sessionBest = num;
			}
			UserLifetimeStats.ReportRunnerScore(profileKey, num);
			view?.Destroy();
		}
	}
	internal static class SpectateStrips
	{
		private class View
		{
			public GameObject go;

			public RunnerFieldView field;

			public UiKit.Label score;

			public UiKit.Label overLabel;

			public float lastAt;

			public float scroll;

			public float ownerFieldW;
		}

		private const float StripH = 88f;

		private const float StripCenterY = -258f;

		private const float FieldDesignH = 146f;

		private const float FieldScale = 0.5753425f;

		private static readonly Dictionary<uint, View> views = new Dictionary<uint, View>();

		private static readonly List<uint> prune = new List<uint>();

		public static void Tick()
		{
			if (!CommandoSprites.Ready)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			prune.Clear();
			foreach (KeyValuePair<uint, View> view2 in views)
			{
				if ((Object)(object)view2.Value.go == (Object)null || !ArcadeSpectate.Latest.TryGetValue(view2.Key, out var value) || unscaledTime - value.receivedAt > 1.2f)
				{
					prune.Add(view2.Key);
				}
			}
			foreach (uint item in prune)
			{
				if ((Object)(object)views[item].go != (Object)null)
				{
					Object.Destroy((Object)(object)views[item].go);
				}
				views[item].field?.Destroy();
				views.Remove(item);
			}
			foreach (KeyValuePair<uint, ArcadeSpectate.Snapshot> item2 in ArcadeSpectate.Latest)
			{
				ArcadeSpectate.Snapshot value2 = item2.Value;
				if (unscaledTime - value2.receivedAt > 1.2f)
				{
					continue;
				}
				if (!views.TryGetValue(item2.Key, out var value3) || (Object)(object)value3.go == (Object)null)
				{
					if (!LoadingOverlay.TryGetCardTransform(item2.Key, out var t, out var width))
					{
						continue;
					}
					value3 = (views[item2.Key] = Build(t, width));
				}
				Update(value3, value2, unscaledTime);
			}
		}

		public static void Clear()
		{
			foreach (View value in views.Values)
			{
				if ((Object)(object)value.go != (Object)null)
				{
					Object.Destroy((Object)(object)value.go);
				}
				value.field?.Destroy();
			}
			views.Clear();
		}

		private static View Build(Transform card, float cardW)
		{
			//IL_001a: 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_0036: 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_00be: 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_010a: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			UiWindow uiWindow = new UiWindow("spectateStrip", card, new Color(0.03f, 0.035f, 0.05f, 0.94f), UiKit.Outline);
			uiWindow.Rect.sizeDelta = new Vector2(cardW, 88f);
			uiWindow.Rect.anchoredPosition = new Vector2(0f, -258f);
			RectTransform parent = uiWindow.AddMaskedContent();
			View view = new View();
			view.go = uiWindow.Go;
			view.ownerFieldW = ArcadeHost.RunnerFieldWidthFor(cardW);
			view.field = new RunnerFieldView("field", parent, (cardW - 4f) / 0.5753425f, 146f, 8);
			view.field.SetScale(0.5753425f);
			view.score = UiKit.CreateLabel("score", (Transform)(object)parent, 13f, UiKit.TextPale, (TextAnchor)5);
			view.score.Rect.sizeDelta = new Vector2(70f, 16f);
			view.score.Rect.anchoredPosition = new Vector2(cardW * 0.5f - 41f, 31f);
			view.overLabel = UiKit.CreateLabel("over", (Transform)(object)parent, 12f, UiKit.Gold, (TextAnchor)4);
			view.overLabel.Rect.sizeDelta = new Vector2(cardW - 20f, 16f);
			view.overLabel.Rect.anchoredPosition = new Vector2(0f, 10f);
			return view;
		}

		private static void Update(View v, ArcadeSpectate.Snapshot snap, float now)
		{
			float w = v.field.W;
			float num = (0f - v.field.H) * 0.5f + 18f;
			v.field.SetPlayer(v.field.PlayerX, num + (float)(int)snap.playerY, snap.colorway, snap.gameOver ? 0.06f : now, snap.ducking, snap.gameOver);
			float num2 = w / v.ownerFieldW;
			if (v.lastAt > 0f && !snap.gameOver)
			{
				v.scroll += snap.speedPxS * (now - v.lastAt) * num2;
			}
			v.lastAt = now;
			float num3 = (snap.gameOver ? 0f : (snap.speedPxS * (now - snap.receivedAt) * num2));
			for (int i = 0; i < 8; i++)
			{
				if (i >= snap.obstacles.Count)
				{
					v.field.HideObstacle(i);
					continue;
				}
				(byte kind, byte x) tuple = snap.obstacles[i];
				byte item = tuple.kind;
				byte item2 = tuple.x;
				CommandoSprites.Critter critter = (CommandoSprites.Critter)Mathf.Clamp((int)item, 0, 3);
				float num4 = (float)(int)item2 / 255f * w - w * 0.5f - num3;
				if (num4 < (0f - w) * 0.5f - 60f)
				{
					v.field.HideObstacle(i);
					continue;
				}
				float num5 = num;
				if (critter == CommandoSprites.Critter.Drone)
				{
					num5 += RunnerGame.DroneFlightY(num4, 0f);
				}
				v.field.SetObstacle(i, critter, num4, num5, now);
			}
			v.field.DrawGround(v.scroll);
			v.field.Flush();
			v.score.Text = snap.score.ToString();
			v.overLabel.Text = (snap.gameOver ? $"caught at {snap.score}" : "");
		}
	}
	internal class TerrariumCore
	{
		public const int W = 156;

		public const int H = 58;

		public const byte CellAir = 0;

		public const byte CellDirt = 1;

		public const byte CellCrystal = 2;

		private const byte TypeMask = 15;

		private const int MatShift = 4;

		public const float CellsPerM3 = 0.03f;

		public static readonly double[] StageAt = new double[5] { 0.0, 1500.0, 25000.0, 120000.0, 500000.0 };

		public const int MaxStage = 4;

		public const double PrestigeTrancheM3 = 150000.0;

		public readonly byte[] cells = new byte[9048];

		public double eatenM3;

		public double pouredM3;

		public const float CandyCostM3 = 50000f;

		public const float PillCostM3 = 5000f;

		public const int MaxCanisterLots = 24;

		public static byte CellType(byte c)
		{
			return (byte)(c & 0xF);
		}

		public static int CellMat(byte c)
		{
			return c >> 4;
		}

		public static byte Pack(byte type, int mat)
		{
			return (byte)((type & 0xF) | (mat << 4));
		}

		public bool InBounds(int x, int y)
		{
			if (x >= 0 && x < 156 && y >= 0)
			{
				return y < 58;
			}
			return false;
		}

		public static uint Step(ref uint s)
		{
			if (s == 0)
			{
				s = 1u;
			}
			s ^= s << 13;
			s ^= s >> 17;
			s ^= s << 5;
			return s;
		}

		public bool Solid(int x, int y)
		{
			if (InBounds(x, y))
			{
				return (cells[y * 156 + x] & 0xF) != 0;
			}
			return true;
		}

		public byte At(int x, int y)
		{
			if (!InBounds(x, y))
			{
				return 0;
			}
			return cells[y * 156 + x];
		}

		public void Generate(ref uint rng, int starterMat)
		{
			Array.Clear(cells, 0, cells.Length);
			int num = 17;
			for (int i = 0; i < 156; i++)
			{
				int num2 = num + (int)(Step(ref rng) % 4);
				for (int j = 0; j < num2; j++)
				{
					cells[j * 156 + i] = Pack(1, starterMat);
				}
			}
			for (int k = 0; k < 2; k++)
			{
				int cx = (int)(20 + Step(ref rng) % 116);
				int cy = (int)(4 + Step(ref rng) % (uint)(num - 6));
				DigCircle(cx, cy, (int)(3 + Step(ref rng) % 3));
			}
		}

		public int Pour(float m3, int mat)
		{
			if (m3 <= 0f)
			{
				return 0;
			}
			pouredM3 += m3;
			eatenM3 += m3;
			return Math.Min((int)(m3 * 0.03f), 9048);
		}

		public bool DropCell(int x, int mat)
		{
			if (x < 0 || x >= 156)
			{
				return false;
			}
			for (int i = 0; i < 58; i++)
			{
				if ((cells[i * 156 + x] & 0xF) == 0)
				{
					cells[i * 156 + x] = Pack(1, mat);
					return true;
				}
			}
			return false;
		}

		public float Fill()
		{
			int num = 0;
			for (int i = 0; i < cells.Length; i++)
			{
				if ((cells[i] & 0xF) != 0)
				{
					num++;
				}
			}
			return (float)num / 9048f;
		}

		public void CompactBottomRow()
		{
			for (int i = 0; i < 57; i++)
			{
				Array.Copy(cells, (i + 1) * 156, cells, i * 156, 156);
			}
			Array.Clear(cells, 8892, 156);
		}

		public int DigCircle(int cx, int cy, int r)
		{
			int num = 0;
			for (int i = cy - r; i <= cy + r; i++)
			{
				if (i < 0 || i >= 58)
				{
					continue;
				}
				for (int j = cx - r; j <= cx + r; j++)
				{
					if (j >= 0 && j < 156 && (j - cx) * (j - cx) + (i - cy) * (i - cy) <= r * r)
					{
						int num2 = i * 156 + j;
						if ((cells[num2] & 0xF) != 0)
						{
							cells[num2] = 0;
							num++;
						}
					}
				}
			}
			return num;
		}

		public float GroundBelow(int x, float fromY)
		{
			for (int num = Math.Min((int)fromY, 57); num >= 0; num--)
			{
				if (Solid(x, num))
				{
					return num + 1;
				}
			}
			return 0f;
		}

		public bool DirtReachable(int sx, int sy)
		{
			if (Solid(sx, sy))
			{
				return true;
			}
			bool[] array = new bool[9048];
			Queue<int> queue = new Queue<int>();
			queue.Enqueue(sy * 156 + sx);
			array[sy * 156 + sx] = true;
			while (queue.Count > 0)
			{
				int num = queue.Dequeue();
				int num2 = num % 156;
				int num3 = num / 156;
				for (int i = 0; i < 4; i++)
				{
					int num4 = num2 + i switch
					{
						1 => -1, 
						0 => 1, 
						_ => 0, 
					};
					int num5 = num3 + i switch
					{
						3 => -1, 
						2 => 1, 
						_ => 0, 
					};
					if (!InBounds(num4, num5))
					{
						continue;
					}
					int num6 = num5 * 156 + num4;
					if (!array[num6])
					{
						if ((cells[num6] & 0xF) != 0)
						{
							return true;
						}
						array[num6] = true;
						queue.Enqueue(num6);
					}
				}
			}
			return false;
		}

		public int Stage()
		{
			int result = 0;
			for (int num = StageAt.Length - 1; num >= 1; num--)
			{
				if (eatenM3 >= StageAt[num])
				{
					result = num;
					break;
				}
			}
			return result;
		}

		public float StageProgress()
		{
			int num = Stage();
			if (num >= 4)
			{
				return 1f;
			}
			double num2 = StageAt[num];
			double num3 = StageAt[num + 1];
			return (float)((eatenM3 - num2) / (num3 - num2));
		}

		public int PrestigeRollsEarned()
		{
			if (!(eatenM3 <= StageAt[4]))
			{
				return (int)((eatenM3 - StageAt[4]) / 150000.0);
			}
			return 0;
		}

		public static bool SpendCandy(List<(int mat, float m3)> lots)
		{
			return SpendLots(lots, 50000f);
		}

		public static bool SpendLots(List<(int mat, float m3)> lots, float cost)
		{
			float num = 0f;
			foreach (var lot in lots)
			{
				float item = lot.m3;
				num += item;
			}
			if (num < cost)
			{
				return false;
			}
			float num2 = cost;
			while (num2 > 0f && lots.Count > 0)
			{
				var (item2, num3) = lots[0];
				if (num3 > num2 + 0.01f)
				{
					lots[0] = (item2, num3 - num2);
					num2 = 0f;
				}
				else
				{
					num2 -= num3;
					lots.RemoveAt(0);
				}
			}
			return true;
		}

		public bool ShrinkStage()
		{
			int num = Stage();
			if (num <= 0)
			{
				return false;
			}
			eatenM3 = StageAt[num - 1];
			return true;
		}

		public string SaveGrid()
		{
			List<byte> list = new List<byte>(1024);
			int j;
			for (int i = 0; i < cells.Length; i += j)
			{
				byte b = cells[i];
				for (j = 1; i + j < cells.Length && cells[i + j] == b && j < 255; j++)
				{
				}
				list.Add((byte)j);
				list.Add(b);
			}
			return $"{156}x{58}:" + Convert.ToBase64String(list.ToArray()).TrimEnd('=');
		}

		public static void AddLot(List<(int mat, float m3)> lots, int mat, float m3)
		{
			if (m3 <= 0f)
			{
				return;
			}
			if (lots.Count > 0 && lots[lots.Count - 1].mat == mat)
			{
				(int, float) tuple = lots[lots.Count - 1];
				lots[lots.Count - 1] = (mat, tuple.Item2 + m3);
				return;
			}
			lots.Add((mat, m3));
			if (lots.Count > 24)
			{
				(int, float) value = ((lots[0].m3 >= lots[1].m3) ? lots[0].mat : lots[1].mat, lots[0].m3 + lots[1].m3);
				lots.RemoveAt(1);
				lots[0] = value;
			}
		}

		public static string SaveLots(List<(int mat, float m3)> lots)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (var (value, num) in lots)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(';');
				}
				stringBuilder.Append(value).Append(':').Append(num.ToString("0.##", CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		public static List<(int mat, float m3)> LoadLots(string token)
		{
			List<(int, float)> list = new List<(int, float)>();
			if (string.IsNullOrEmpty(token))
			{
				return list;
			}
			string[] array = token.Split(';');
			foreach (string text in array)
			{
				int num = text.IndexOf(':');
				if (num > 0 && int.TryParse(text.Substring(0, num), out var result) && float.TryParse(text.Substring(num + 1), NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && result2 > 0f && result >= 0 && result < 16)
				{
					list.Add((result, result2));
				}
			}
			return list;
		}

		public bool LoadGrid(string token)
		{
			if (string.IsNullOrEmpty(token))
			{
				return false;
			}
			int num = token.IndexOf(':');
			if (num <= 0 || token.Substring(0, num) != $"{156}x{58}")
			{
				return false;
			}
			string text = token.Substring(num + 1);
			int num2 = (4 - text.Length % 4) % 4;
			if (num2 == 3)
			{
				return false;
			}
			byte[] array;
			try
			{
				array = Convert.FromBase64String(text + new string('=', num2));
			}
			catch
			{
				return false;
			}
			if ((array.Length & 1) != 0)
			{
				return false;
			}
			int num3 = 0;
			for (int i = 0; i < array.Length; i += 2)
			{
				int num4 = array[i];
				byte b = array[i + 1];
				if (num3 + num4 > cells.Length)
				{
					return false;
				}
				for (int j = 0; j < num4; j++)
				{
					cells[num3++] = b;
				}
			}
			return num3 == cells.Length;
		}
	}
	internal class TerrariumGame : IMiniGame
	{
		internal enum PetState
		{
			Sleep,
			Idle,
			Walk,
			DigTo,
			Eat,
			Evolve
		}

		private class Mote
		{
			public float x;

			public float y;

			public float vy;

			public float life;

			public Color32 col;
		}

		private const float CompactBelow = 600f;

		private const int TickHz = 30;

		private const int DropCellsPerTick = 3;

		private const float CompactAbove = 0.62f;

		private const int TreatsPerScreen = 3;

		private const float CanisterFullM3 = 40000f;

		internal const int PetSurfW = 34;

		internal const int PetSurfH = 28;

		internal const int PetAnchorX = 17;

		internal const int PetAnchorY = 4;

		private static readonly string[] StageNames = new string[5] { "PEBBLE", "CHIP", "GEODELING", "GOLEMLING", "MAGMALET" };

		private static readonly int[] BiteR = new int[5] { 1, 1, 2, 2, 3 };

		private static readonly Dictionary<uint, float[]> fedClasses = new Dictionary<uint, float[]>();

		private static readonly Color32[] ClassBase = (Color32[])(object)new Color32[8]
		{
			new Color32((byte)104, (byte)78, (byte)50, byte.MaxValue),
			new Color32((byte)112, (byte)112, (byte)120, byte.MaxValue),
			new Color32((byte)96, (byte)106, (byte)122, byte.MaxValue),
			new Color32((byte)150, (byte)132, (byte)188, byte.MaxValue),
			new Color32((byte)188, (byte)208, (byte)226, byte.MaxValue),
			new Color32((byte)110, (byte)74, (byte)52, byte.MaxValue),
			new Color32((byte)178, (byte)154, (byte)104, byte.MaxValue),
			new Color32((byte)74, (byte)44, (byte)34, byte.MaxValue)
		};

		private ArcadeContext ctx;

		private bool compact;

		private float cellPx = 3f;

		private Vector2 tankCenter;

		private PixelSurface tank;

		private PixelSurface petLayer;

		private PixelSurface foilLayer;

		private PixelSurface skinLayer;

		private Color32[] skinBuf;

		private int skinOffX;

		private int skinOffY;

		private PetSprite.SetPx skinBlit;

		private PetSprite.SetPx petBlit;

		private PetSprite.SetPx foilBlit;

		private TerrariumCore core;

		private string profileKey;

		private uint ownerNetId;

		private uint petSeed;

		private Random rng;

		private UiKit.Label stageLabel;

		private UiMeter stageMeter;

		private UiKit.Label traitLabel;

		private UiKit.Label mealLabel;

		private UiKit.Label canisterLabel;

		private UiKit.Btn feedBtn;

		private UiKit.Btn rerollBtn;

		private UiKit.Btn pillBtn;

		private PixelSurface canister;

		private float rerollArmedUntil;

		private float pillArmedUntil;

		private List<(int mat, float m3)> lots = new List<(int, float)>();

		private readonly Queue<(int mat, int cells, float col)> pourQueue = new Queue<(int, int, float)>();

		private int pourCellsLeft;

		private int pourMat;

		private int pourTotalCells;

		private int pourDoneCells;

		private float pourColumn;

		private PetState state;

		private float petX;

		private float petY;

		private int facing = 1;

		private float squash = 1f;

		private float blinkUntil;

		private float nextBlinkAt;

		private float blinkPeriod;

		private float eyeWiden;

		private float stateUntil;

		private int targetX;

		private int targetY;

		private float chewPulse;

		private float belly;

		private int treatsLeft = 3;

		private bool evolvePending;

		private float evolveAt;

		private float tickCarry;

		private PetSprite.Look look;

		private readonly List<Mote> motes = new List<Mote>(24);

		private bool carveCollected;

		private float lastPatAt;

		private int patStreak;

		private static int debugFoil = -1;

		private List<(int mat, float m3)> lastPour = new List<(int, float)>();

		private float feedLevel;

		public static void OnRunEnd()
		{
			fedClasses.Clear();
		}

		public void Start(ArcadeContext c)
		{
			ctx = c;
			profileKey = ArcadeLocal.ProfileKey();
			ownerNetId = ArcadeLocal.NetId();
			rng = new Random(-1636326022 ^ Environment.TickCount);
			core = new TerrariumCore();
			petSeed = UserLifetimeStats.PetSeed(profileKey);
			if (petSeed == 0)
			{
				petSeed = (uint)((Environment.TickCount * -1640531535) ^ rng.Next());
				if (petSeed == 0)
				{
					petSeed = 1u;
				}
				UserLifetimeStats.SetPetSeed(profileKey, petSeed);
			}
			core.eatenM3 = UserLifetimeStats.PetEaten(profileKey);
			lots = TerrariumCore.LoadLots(UserLifetimeStats.PetCanister(profileKey));
			uint num = petSeed | 1;
			if (!core.LoadGrid(UserLifetimeStats.TankGrid(profileKey)))
			{
				core.Generate(ref num, 0);
			}
			BuildUi();
			DeriveLook();
			petX = 78f;
			petY = SurfaceYAt((int)petX);
			nextBlinkAt = Time.unscaledTime + blinkPeriod;
			carveCollected = CollectCarve();
			state = ((core.eatenM3 > 0.0 && lots.Count > 0) ? PetState.Idle : PetState.Sleep);
			TerrariumUnlocks.ReconcileRolls(profileKey, core.Stage());
			TerrariumNet.LocalOpened();
		}

		private void BuildUi()
		{
			//IL_00a5: 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_00aa: 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)
			compact = ctx.width < 600f;
			cellPx = (compact ? 2f : 3f);
			float num = 156f * cellPx;
			float num2 = 58f * cellPx;
			tankCenter = (compact ? new Vector2(0f, ctx.height * 0.5f - num2 * 0.5f - 2f) : new Vector2((0f - ctx.width) * 0.5f + 6f + num * 0.5f, 0f));
			tank = new PixelSurface("terrarium", (Transform)(object)ctx.panel, 156, 58, cellPx);
			((Graphic)tank.Image).rectTransform.anchoredPosition = tankCenter;
			skinLayer = new PixelSurface("petSkin", (Transform)(object)ctx.panel, 102, 84, cellPx / 3f);
			skinBlit = BlitSkinCell;
			petLayer = new PixelSurface("pet", (Transform)(object)ctx.panel, 34, 28, cellPx);
			foilLayer = new PixelSurface("petFoil", (Transform)(object)ctx.panel, 102, 84, cellPx / 3f);
			petBlit = delegate(int x, int y, byte r2, byte g2, byte b2)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				petLayer.Set(x, y, new Color32(r2, g2, b2, byte.MaxValue));
			};
			foilBlit = delegate(int x, int y, byte r2, byte g2, byte b2)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				foilLayer.Set(x, y, new Color32(r2, g2, b2, byte.MaxValue));
			};
			if (compact)
			{
				BuildCompactControls(num, num2);
			}
			else
			{
				BuildFullControls();
			}
		}

		private void BuildFullControls()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_0105: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Expected O, but got Unknown
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			float num = ctx.width * 0.5f;
			float num2 = num - 210f + 21f;
			float stackX = num - 160f + 76f;
			canister = new PixelSurface("canister", (Transform)(object)ctx.panel, 14, 40, cellPx);
			((Graphic)canister.Image).rectTransform.anchoredPosition = new Vector2(num2, 0f);
			float y = ctx.height * 0.5f;
			stageLabel = Row("stage", 13f, 16f, UiKit.Gold, (TextAnchor)4);
			traitLabel = Row("traits", 8f, 11f, UiKit.TextDim, (TextAnchor)4);
			traitLabel.ClipSingleLine();
			stageMeter = new UiMeter("stagebar", (Transform)(object)ctx.panel, new Vector2(152f, 7f), new Color(0.1f, 0.1f, 0.14f, 1f), UiKit.Gold, 1f);
			y -= 5.5f;
			stageMeter.Rect.anchoredPosition = new Vector2(stackX, y);
			y -= 3.5f;
			mealLabel = Row("meal", 10f, 24f, UiKit.TextPale, (TextAnchor)4);
			mealLabel.WrapClipped();
			canisterLabel = Row("canLabel", 9f, 24f, UiKit.TextDim, (TextAnchor)4);
			canisterLabel.WrapClipped();
			feedBtn = UiKit.CreateButton("feed", (Transform)(object)ctx.panel, new Vector2(152f, 24f), 12f, "FEED", new UnityAction(FeedClicked));
			y -= 14f;
			feedBtn.Rect.anchoredPosition = new Vector2(stackX, y);
			y -= 14f;
			rerollBtn = UiKit.CreateButton("reroll", (Transform)(object)ctx.panel, new Vector2(152f, 20f), 10f, "CHANGE CANDY", new UnityAction(RerollClicked));
			y -= 12f;
			rerollBtn.Rect.anchoredPosition = new Vector2(stackX, y);
			y -= 12f;
			pillBtn = UiKit.CreateButton("pill", (Transform)(object)ctx.panel, new Vector2(152f, 20f), 10f, "SHRINK PILL", new UnityAction(PillClicked));
			y -= 12f;
			pillBtn.Rect.anchoredPosition = new Vector2(stackX, y);
			UiKit.Label Row(string name, float size, float h, Color col, TextAnchor anchor)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				UiKit.Label label = UiKit.CreateLabel(name, (Transform)(object)ctx.panel, size, col, anchor);
				label.Rect.sizeDelta = new Vector2(152f, h);
				y -= h * 0.5f + 2f;
				label.Rect.anchoredPosition = new Vector2(stackX, y);
				y -= h * 0.5f;
				return label;
			}
		}

		private void BuildCompactControls(float tankW, float tankH)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			//IL_0210: 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_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			float num = (tankCenter.y - tankH * 0.5f - 4f + (0f - ctx.height) * 0.5f) * 0.5f;
			float num2 = (0f - tankW) * 0.5f;
			canister = new PixelSurface("canister", (Transform)(object)ctx.panel, 14, 28, cellPx);
			((Graphic)canister.Image).rectTransform.anchoredPosition = new Vector2(num2 + 14f, num);
			stageLabel = UiKit.CreateLabel("stage", (Transform)(object)ctx.panel, 11f, UiKit.Gold, (TextAnchor)3);
			stageLabel.Rect.sizeDelta = new Vector2(tankW * 0.5f - 40f, 16f);
			stageLabel.Rect.anchoredPosition = new Vector2(num2 + 34f + (tankW * 0.5f - 40f) * 0.5f, num + 14f);
			stageLabel.ClipSingleLine();
			mealLabel = UiKit.CreateLabel("meal", (Transform)(object)ctx.panel, 9f, UiKit.TextPale, (TextAnchor)3);
			mealLabel.Rect.sizeDelta = new Vector2(tankW * 0.5f - 40f, 24f);
			mealLabel.Rect.anchoredPosition = new Vector2(num2 + 34f + (tankW * 0.5f - 40f) * 0.5f, num - 10f);
			mealLabel.WrapClipped();
			traitLabel = null;
			canisterLabel = null;
			float num3 = tankW * 0.5f - 52f;
			feedBtn = UiKit.CreateButton("feed", (Transform)(object)ctx.panel, new Vector2(100f, 20f), 11f, "FEED", new UnityAction(FeedClicked));
			feedBtn.Rect.anchoredPosition = new Vector2(num3, num + 16f);
			rerollBtn = UiKit.CreateButton("reroll", (Transform)(object)ctx.panel, new Vector2(100f, 16f), 9f, "CHANGE CANDY", new UnityAction(RerollClicked));
			rerollBtn.Rect.anchoredPosition = new Vector2(num3, num - 2f);
			pillBtn = UiKit.CreateButton("pill", (Transform)(object)ctx.panel, new Vector2(100f, 16f), 9f, "SHRINK PILL", new UnityAction(PillClicked));
			pillBtn.Rect.anchoredPosition = new Vector2(num3, num - 19f);
		}

		private bool CollectCarve()
		{
			if (ownerNetId == 0)
			{
				return true;
			}
			float[] array = new float[8];
			if (StageSyncCoordinator.IsServer)
			{
				float[] runClasses = CarveStats.GetRunClasses(ownerNetId);
				for (int i = 0; i < 8; i++)
				{
					array[i] = runClasses[i];
				}
			}
			else
			{
				RosterEntry rosterEntry = LoadingRoster.Find(ownerNetId);
				if (rosterEntry?.matShare == null)
				{
					return false;
				}
				for (int j = 0; j < 8 && j < rosterEntry.matShare.Length; j++)
				{
					array[j] = (float)(int)rosterEntry.matShare[j] / 255f * rosterEntry.m3Run;
				}
			}
			if (!fedClasses.TryGetValue(ownerNetId, out var value))
			{
				value = (fedClasses[ownerNetId] = new float[8]);
			}
			bool flag = false;
			for (int k = 0; k < 8; k++)
			{
				float num = array[k] - value[k];
				if (num > 0.5f)
				{
					TerrariumCore.AddLot(lots, k, num);
					value[k] = array[k];
					flag = true;
				}
			}
			if (!flag)
			{
				return true;
			}
			UserLifetimeStats.SetPetCanister(profileKey, TerrariumCore.SaveLots(lots));
			eyeWiden = 1.2f;
			return true;
		}

		private void FeedClicked()
		{
			if (lots.Count == 0)
			{
				return;
			}
			bool flag = core.eatenM3 <= 0.0;
			int num = core.Stage();
			float num2 = 0f;
			foreach (var lot in lots)
			{
				float item = lot.m3;
				num2 += item;
			}
			feedLevel = CanisterLevel(num2);
			float num3 = 0f;
			lastPour.Clear();
			foreach (var lot2 in lots)
			{
				int item2 = lot2.mat;
				float item3 = lot2.m3;
				int num4 = core.Pour(item3, item2);
				if (num4 > 0)
				{
					pourQueue.Enqueue((item2, num4, -1f));
				}
				pourTotalCells += num4;
				num3 += item3;
				lastPour.Add((item2, item3));
			}
			lots.Clear();
			UserLifetimeStats.SetPetCanister(profileKey, "");
			UserLifetimeStats.SetPetEaten(profileKey, core.eatenM3);
			Wake();
			if (flag)
			{
				TerrariumUnlocks.GrantStarter(profileKey);
			}
			if (core.Stage() > num)
			{
				evolvePending = true;
				evolveAt = Time.unscaledTime + 4f;
			}
			TerrariumUnlocks.CheckPrestige(profileKey, core);
		}

		public void Tick(float dt)
		{
			tickCarry += dt;
			while (tickCarry >= 1f / 30f)
			{
				tickCarry -= 1f / 30f;
				Step(1f / 30f);
			}
			if (!carveCollected)
			{
				carveCollected = CollectCarve();
			}
			if (ModOptions.TestButtons != null && ModOptions.TestButtons.Value && Input.GetKeyDown((KeyCode)292))
			{
				if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305))
				{
					TerrariumSkins.DebugCycleFire();
				}
				else if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
				{
					debugFoil = ((debugFoil == -1) ? 5 : ((debugFoil == 5) ? 6 : (-1)));
					DeriveLook();
					Wake();
					ManualLogSource log = ScorchedVoxelsPlugin.Log;
					object obj;
					if (debugFoil >= 0)
					{
						PetSprite.Foil foil = (PetSprite.Foil)debugFoil;
						obj = foil.ToString();
					}
					else
					{
						obj = "off (the seed's truth)";
					}
					log.LogInfo((object)("[terrarium] debug foil: " + (string?)obj));
				}
				else
				{
					float num = 200000f;
					while (num > 0f)
					{
						float num2 = Mathf.Min(num, 10000f + (float)rng.NextDouble() * 40000f);
						TerrariumCore.AddLot(lots, rng.Next(8), num2);
						num -= num2;
					}
					UserLifetimeStats.SetPetCanister(profileKey, TerrariumCore.SaveLots(lots));
					eyeWiden = 1.2f;
					ScorchedVoxelsPlugin.Log.LogInfo((object)"[terrarium] debug fill: +200k m³ into the canister");
				}
			}
			HandleClicks();
			Render();
			tank.Flush();
			petLayer.Flush();
			foilLayer.Flush();
			skinLayer.Flush();
			canister.Flush();
			TerrariumNet.StreamLocal(ownerNetId, core, petSeed, petX, petY, PoseByte());
			RefreshHud();
		}

		private void Step(float dt)
		{
			if (pourCellsLeft <= 0 && pourQueue.Count > 0)
			{
				(int, int, float) tuple = pourQueue.Dequeue();
				pourMat = tuple.Item1;
				pourCellsLeft = tuple.Item2;
				pourColumn = ((tuple.Item3 >= 0f) ? Mathf.Clamp(tuple.Item3, 4f, 151f) : (156f * (0.3f + 0.4f * (float)rng.NextDouble())));
			}
			if (pourCellsLeft > 0)
			{
				for (int i = 0; i < 3; i++)
				{
					if (pourCellsLeft <= 0)
					{
						break;
					}
					pourColumn += (float)(rng.NextDouble() - 0.5) * 6f;
					pourColumn = Mathf.Clamp(pourColumn, 4f, 151f);
					if (core.Fill() >= 0.62f)
					{
						core.CompactBottomRow();
					}
					if (core.DropCell((int)pourColumn, pourMat))
					{
						pourCellsLeft--;
						pourDoneCells++;
					}
					else
					{
						pourDoneCells += pourCellsLeft;
						pourCellsLeft = 0;
					}
				}
				if (pourQueue.Count == 0 && pourCellsLeft == 0)
				{
					pourTotalCells = (pourDoneCells = 0);
				}
				Wake();
			}
			if (evolvePending && Time.unscaledTime >= evolveAt)
			{
				Evolve();
			}
			StepPet(dt);
			StepMotes(dt);
		}

		private void StepPet(float dt)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: 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_0525: Unknown result type (might be due to invalid IL or missing references)
			float unscaledTime = Time.unscaledTime;
			squash = Mathf.MoveTowards(squash, 1f, dt * 4f);
			if (eyeWiden > 0f)
			{
				eyeWiden -= dt;
			}
			if (belly > 0f)
			{
				belly -= dt;
			}
			if (evolvePending && state != PetState.Sleep && rng.NextDouble() < (double)dt * 1.5)
			{
				SpawnMote(petX, petY + (float)PetSprite.H[core.Stage()] + 2f, 5f, new Color32(byte.MaxValue, (byte)224, (byte)120, byte.MaxValue));
			}
			if (unscaledTime >= nextBlinkAt)
			{
				blinkUntil = unscaledTime + 0.09f;
				nextBlinkAt = unscaledTime + blinkPeriod * (0.7f + 0.6f * (float)rng.NextDouble());
			}
			switch (state)
			{
			case PetState.Sleep:
				if (core.eatenM3 > 0.0 && rng.NextDouble() < (double)(dt * 0.4f))
				{
					SpawnMote(petX, petY + (float)PetSprite.H[core.Stage()] + 1f, 5f, new Color32((byte)150, (byte)150, (byte)165, byte.MaxValue));
				}
				break;
			case PetState.Idle:
				Gravity(dt);
				if (pourCellsLeft > 0)
				{
					if (Mathf.Abs(pourColumn - petX) > 3f)
					{
						WalkToward(pourColumn, dt);
					}
					else
					{
						BeginEat();
					}
				}
				else if (unscaledTime >= stateUntil)
				{
					if (rng.NextDouble() < 0.35)
					{
						targetX = 6 + rng.Next(144);
						targetY = Mathf.Max(1, (int)SurfaceYAt(targetX) - rng.Next(6));
						state = PetState.DigTo;
					}
					else
					{
						targetX = Mathf.Clamp((int)petX + rng.Next(-30, 31), 4, 151);
						state = PetState.Walk;
					}
					stateUntil = unscaledTime + 2f + (float)rng.NextDouble() * 3f;
				}
				break;
			case PetState.Walk:
				Gravity(dt);
				WalkToward(targetX, dt);
				if (Mathf.Abs((float)targetX - petX) < 1.5f || unscaledTime >= stateUntil)
				{
					ToIdle();
				}
				break;
			case PetState.DigTo:
			{
				float num = (float)targetX - petX;
				float num2 = (float)targetY - petY;
				if (Mathf.Abs(num) < 1.5f && Mathf.Abs(num2) < 1.5f)
				{
					ToIdle();
					break;
				}
				facing = ((num >= 0f) ? 1 : (-1));
				int num3 = core.Stage();
				float num4 = 9f + 2f * (float)num3;
				petX += Mathf.Clamp(num, -1f, 1f) * num4 * dt * 0.7f;
				petY += Mathf.Clamp(num2, -1f, 1f) * num4 * dt * 0.5f;
				if (core.DigCircle((int)petX + facing, (int)(petY + (float)PetSprite.H[num3] * 0.5f), BiteR[num3]) > 0)
				{
					chewPulse += dt * 8f;
					squash = 0.82f + 0.15f * Mathf.Sin(chewPulse * 9f);
					if (rng.NextDouble() < 0.4)
					{
						SpawnCrumb();
					}
				}
				else if (!core.Solid((int)petX, (int)petY - 1))
				{
					Gravity(dt);
				}
				break;
			}
			case PetState.Eat:
				Gravity(dt);
				chewPulse += dt;
				squash = 0.86f + 0.12f * Mathf.Sin(chewPulse * 12f);
				if (rng.NextDouble() < (double)(dt * 3f))
				{
					SpawnCrumb();
				}
				if (rng.NextDouble() < (double)(dt * 0.5f))
				{
					eyeWiden = 0.4f;
				}
				if (pourCellsLeft <= 0 && pourQueue.Count == 0)
				{
					belly = 4f;
					SpawnMote(petX, petY + (float)PetSprite.H[core.Stage()] + 2f, 5f, new Color32((byte)220, (byte)90, (byte)110, byte.MaxValue));
					ToIdle();
				}
				break;
			case PetState.Evolve:
				squash = 1f + 0.2f * Mathf.Sin(unscaledTime * 14f);
				if (rng.NextDouble() < (double)(dt * 6f))
				{
					SpawnMote(petX + (float)(rng.NextDouble() - 0.5) * (float)PetSprite.W[core.Stage()], petY + (float)rng.NextDouble() * (float)PetSprite.H[core.Stage()], 5f, new Color32(byte.MaxValue, (byte)224, (byte)120, byte.MaxValue));
				}
				if (unscaledTime >= stateUntil)
				{
					ToIdle();
				}
				break;
			}
		}

		private void Gravity(float dt)
		{
			if (!core.Solid((int)petX, (int)petY - 1))
			{
				float num = core.GroundBelow((int)petX, petY);
				petY -= 26f * dt;
				if (petY <= num)
				{
					petY = num;
					squash = 0.7f;
				}
			}
		}

		private void WalkToward(float x, float dt)
		{
			facing = ((x >= petX) ? 1 : (-1));
			int num = core.Stage();
			float num2 = 8f + 2f * (float)num;
			petX = Mathf.Clamp(petX + (float)facing * num2 * dt, 3f, 152f);
			if (core.Solid((int)(petX + (float)facing), (int)petY))
			{
				if (!core.Solid((int)(petX + (float)facing), (int)petY + 1))
				{
					petY += 1f;
					squash = 1.25f;
				}
				else
				{
					core.DigCircle((int)(petX + (float)facing), (int)petY + 1, BiteR[num]);
				}
			}
			float num3 = core.GroundBelow((int)petX, petY);
			if (petY < num3)
			{
				petY = num3;
			}
		}

		private void BeginEat()
		{
			if (state != PetState.Eat)
			{
				state = PetState.Eat;
				chewPulse = 0f;
				squash = 1.2f;
				eyeWiden = 0.6f;
			}
		}

		private void ToIdle()
		{
			state = PetState.Idle;
			stateUntil = Time.unscaledTime + 1f + (float)rng.NextDouble() * 2f;
		}

		private void PetThePet()
		{
			//IL_009b: 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)
			float unscaledTime = Time.unscaledTime;
			Wake();
			eyeWiden = 1f;
			squash = 1.28f;
			facing = ((rng.Next(2) == 0) ? facing : (-facing));
			SpawnMote(petX + (float)(rng.NextDouble() - 0.5) * 3f, petY + (float)PetSprite.H[core.Stage()] + 2f, 5f, new Color32((byte)220, (byte)90, (byte)110, byte.MaxValue));
			if (unscaledTime - lastPatAt < 0.8f && ++patStreak >= 3)
			{
				patStreak = 0;
				petY += 1.5f;
				squash = 1.4f;
				for (int i = 0; i < 3; i++)
				{
					SpawnMote(petX + (float)(i - 1) * 2.5f, petY + (float)PetSprite.H[core.Stage()] + 2f + (float)i, 4f + (float)i, new Color32((byte)235, (byte)110, (byte)130, byte.MaxValue));
				}
			}
			else if (unscaledTime - lastPatAt >= 0.8f)
			{
				patStreak = 1;
			}
			lastPatAt = unscaledTime;
			if (state == PetState.Idle || state == PetState.Walk)
			{
				state = PetState.Idle;
				stateUntil = unscaledTime + 1.6f;
			}
		}

		private void Wake()
		{
			if (state == PetState.Sleep)
			{
				state = PetState.Idle;
				eyeWiden = 1.2f;
				squash = 1.3f;
				stateUntil = 0f;
			}
		}

		private void Evolve()
		{
			evolvePending = false;
			state = PetState.Evolve;
			stateUntil = Time.unscaledTime + 2.2f;
			DeriveLook();
			TerrariumUnlocks.ReconcileRolls(profileKey, core.Stage());
		}

		private float SurfaceYAt(int x)
		{
			for (int num = 57; num >= 0; num--)
			{
				if (core.Solid(x, num))
				{
					return num + 1;
				}
			}
			return 0f;
		}

		private void DeriveLook()
		{
			look = PetSprite.DeriveLook(petSeed, core.Stage());
			if (debugFoil >= 0)
			{
				look.foil = (PetSprite.Foil)debugFoil;
			}
			blinkPeriod = PetSprite.BlinkPeriod(petSeed);
		}

		private void BlitSkinCell(int cx, int cy, byte r, byte g, byte b)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (skinBuf == null)
			{
				return;
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					int num = cx * 3 + j;
					int num2 = cy * 3 + i;
					if (num >= 0 && num2 >= 0 && num < 102 && num2 < 84)
					{
						skinLayer.Set(num, num2, skinBuf[(skinOffY + num2) * 204 + skinOffX + num]);
					}
				}
			}
		}

		private byte PoseByte()
		{
			return (byte)((uint)state | (uint)((facing > 0) ? 8 : 0) | (uint)((Time.unscaledTime < blinkUntil) ? 16 : 0) | (uint)((eyeWiden > 0f) ? 32 : 0));
		}

		private void HandleClicks()
		{
			if ((!ArcadeInput.ActionDown && !ArcadeInput.RopeDown) || !CellUnderCursor(out var cx, out var cy))
			{
				return;
			}
			if (ArcadeInput.ActionDown)
			{
				int num = core.Stage();
				if (Mathf.Abs((float)cx - petX) <= (float)PetSprite.W[num] * 0.5f + 1f && (float)cy >= petY - 1f && (float)cy <= petY + (float)PetSprite.H[num] + 2f)
				{
					PetThePet();
					return;
				}
				Wake();
				targetX = cx;
				targetY = cy;
				state = PetState.DigTo;
				stateUntil = Time.unscaledTime + 8f;
				squash = 1.2f;
				eyeWiden = 0.8f;
			}
			else if (treatsLeft > 0)
			{
				treatsLeft--;
				Wake();
				pourQueue.Enqueue((0, 10, cx));
			}
		}

		private bool CellUnderCursor(out int cx, out int cy)
		{
			//IL_001a: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			cx = (cy = 0);
			RectTransform rectTransform = ((Graphic)tank.Image).rectTransform;
			Vector2 val = default(Vector2);
			if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, Vector2.op_Implicit(Input.mousePosition), (Camera)null, ref val))
			{
				return false;
			}
			Vector2 sizeDelta = rectTransform.sizeDelta;
			cx = (int)((val.x + sizeDelta.x * 0.5f) / cellPx);
			cy = (int)((val.y + sizeDelta.y * 0.5f) / cellPx);
			if (cx >= 0 && cx < 156 && cy >= 0)
			{
				return cy < 58;
			}
			return false;
		}

		private void RerollClicked()
		{
			if (pourCellsLeft > 0 || pourQueue.Count > 0 || evolvePending)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime > rerollArmedUntil)
			{
				rerollArmedUntil = unscaledTime + 3f;
				return;
			}
			rerollArmedUntil = 0f;
			if (core.eatenM3 > 0.0)
			{
				if (!TerrariumCore.SpendCandy(lots))
				{
					return;
				}
				UserLifetimeStats.SetPetCanister(profileKey, TerrariumCore.SaveLots(lots));
			}
			petSeed = (uint)((Environment.TickCount * -1640531535) ^ rng.Next());
			if (petSeed == 0)
			{
				petSeed = 1u;
			}
			UserLifetimeStats.SetPetSeed(profileKey, petSeed);
			DeriveLook();
			state = PetState.Evolve;
			stateUntil = Time.unscaledTime + 1.6f;
		}

		private void PillClicked()
		{
			if (pourCellsLeft > 0 || pourQueue.Count > 0 || evolvePending || core.Stage() <= 0)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime > pillArmedUntil)
			{
				pillArmedUntil = unscaledTime + 3f;
				return;
			}
			pillArmedUntil = 0f;
			if (TerrariumCore.SpendLots(lots, 5000f))
			{
				core.ShrinkStage();
				UserLifetimeStats.SetPetCanister(profileKey, TerrariumCore.SaveLots(lots));
				UserLifetimeStats.SetPetEaten(profileKey, core.eatenM3);
				DeriveLook();
				state = PetState.Evolve;
				stateUntil = Time.unscaledTime + 1.6f;
			}
		}

		private void Render()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 58; i++)
			{
				for (int j = 0; j < 156; j++)
				{
					tank.Set(j, i, CellColor(core, j, i));
				}
			}
			foreach (Mote mote in motes)
			{
				tank.Set((int)mote.x, (int)mote.y, mote.col);
			}
			petLayer.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			foilLayer.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			skinLayer.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			bool flag = TerrariumSkins.TryGetSkin(look.foil, out skinBuf);
			if (flag)
			{
				skinOffX = (int)(Mathf.Clamp01(petX / 156f) * 102f);
				skinOffY = (int)(Mathf.Clamp01(petY / 58f) * 84f);
			}
			PetSprite.Paint(petBlit, 17, 4, core.Stage(), petSeed, state == PetState.Sleep, Time.unscaledTime < blinkUntil, eyeWiden > 0f, facing, squash, belly > 0f, Time.unscaledTime, foilBlit, flag, look.foil, core.eatenM3 <= 0.0, flag ? skinBlit : null);
			Vector2 anchoredPosition = ((Graphic)tank.Image).rectTransform.anchoredPosition;
			float num = anchoredPosition.x - 156f * cellPx * 0.5f + Mathf.Round(petX) * cellPx;
			float num2 = anchoredPosition.y - 58f * cellPx * 0.5f + Mathf.Round(petY) * cellPx;
			Vector2 anchoredPosition2 = default(Vector2);
			((Vector2)(ref anchoredPosition2))..ctor(num + 0f * cellPx, num2 + 10f * cellPx);
			((Graphic)petLayer.Image).rectTransform.anchoredPosition = anchoredPosition2;
			((Graphic)foilLayer.Image).rectTransform.anchoredPosition = anchoredPosition2;
			((Graphic)skinLayer.Image).rectTransform.anchoredPosition = anchoredPosition2;
			RenderCanister();
		}

		private static float CanisterLevel(float totalM3)
		{
			if (!(totalM3 <= 0f))
			{
				return Mathf.Sqrt(Mathf.Clamp01(totalM3 / 40000f));
			}
			return 0f;
		}

		private void RenderCanister()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			Color32 val = default(Color32);
			((Color32)(ref val))..ctor((byte)70, (byte)74, (byte)86, byte.MaxValue);
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor((byte)40, (byte)42, (byte)52, byte.MaxValue);
			canister.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			for (int i = 0; i < canister.H; i++)
			{
				canister.Set(0, i, (i % 2 == 0) ? val : val2);
				canister.Set(canister.W - 1, i, (i % 2 == 0) ? val : val2);
			}
			for (int j = 0; j < canister.W; j++)
			{
				canister.Set(j, 0, val);
			}
			for (int k = 1; k < canister.H; k++)
			{
				for (int l = 1; l < canister.W - 1; l++)
				{
					canister.Set(l, k, new Color32((byte)30, (byte)32, (byte)40, (byte)90));
				}
			}
			float num = 0f;
			foreach (var lot in lots)
			{
				float item = lot.m3;
				num += item;
			}
			float num2 = ((lots.Count > 0) ? CanisterLevel(num) : ((pourTotalCells > 0) ? (feedLevel * (1f - (float)pourDoneCells / (float)pourTotalCells)) : 0f));
			int num3 = (int)((float)(canister.H - 2) * num2);
			if (num2 > 0f && num3 < 2)
			{
				num3 = 2;
			}
			if (num3 <= 0 || (lots.Count <= 0 && pourTotalCells <= 0))
			{
				return;
			}
			float num4 = 0f;
			List<(int, float)> list = ((lots.Count > 0) ? lots : lastPour);
			float num5 = 0f;
			foreach (var item5 in list)
			{
				float item2 = item5.Item2;
				num5 += item2;
			}
			if (num5 <= 0f)
			{
				num5 = 1f;
			}
			foreach (var item6 in list)
			{
				int item3 = item6.Item1;
				float item4 = item6.Item2;
				int num6 = 1 + (int)((float)num3 * (num4 / num5));
				num4 += item4;
				int num7 = 1 + (int)((float)num3 * Mathf.Min(1f, num4 / num5));
				Color32 val3 = ClassBase[Mathf.Min(item3, ClassBase.Length - 1)];
				for (int m = num6; m < num7; m++)
				{
					for (int n = 1; n < canister.W - 1; n++)
					{
						canister.Set(n, m, (ArcadeThemes.DressHash(n, m) % 5 == 0) ? ArcadeThemes.Scale(val3, 0.8f) : val3);
					}
				}
			}
		}

		internal static Color32 CellColor(TerrariumCore c, int x, int y)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			byte c2 = c.At(x, y);
			if (TerrariumCore.CellType(c2) == 0)
			{
				Color32 val = default(Color32);
				((Color32)(ref val))..ctor((byte)22, (byte)20, (byte)26, byte.MaxValue);
				if (!ArcadeThemes.StrataBand(x, y, 3, 11, drift: false, 9, 2))
				{
					return val;
				}
				return ArcadeThemes.Scale(val, 0.8f);
			}
			int num = Mathf.Min(TerrariumCore.CellMat(c2), ClassBase.Length - 1);
			Color32 val2 = ClassBase[num];
			uint num2 = ArcadeThemes.DressHash(x, y);
			if (num == 7 && num2 % 9 == 0)
			{
				return new Color32((byte)230, (byte)130, (byte)52, byte.MaxValue);
			}
			if (num == 3 && num2 % 11 == 0)
			{
				return new Color32((byte)214, (byte)200, (byte)240, byte.MaxValue);
			}
			if (num == 2 && num2 % 13 == 0)
			{
				return new Color32((byte)160, (byte)172, (byte)190, byte.MaxValue);
			}
			if (!c.Solid(x, y + 1))
			{
				return ArcadeThemes.Scale(val2, 1.25f);
			}
			if (num2 % 3 != 0)
			{
				return val2;
			}
			return ArcadeThemes.Scale(val2, 0.78f);
		}

		private void SpawnCrumb()
		{
			//IL_0019: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			Color32 col = ClassBase[Mathf.Min(pourMat, ClassBase.Length - 1)];
			SpawnMote(petX + (float)(facing * PetSprite.W[core.Stage()]) * 0.5f, petY + 1f + (float)rng.NextDouble() * 2f, -6f, col);
		}

		private void SpawnMote(float x, float y, float vy, Color32 col)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (motes.Count >= 24)
			{
				motes.RemoveAt(0);
			}
			motes.Add(new Mote
			{
				x = x,
				y = y,
				vy = vy,
				life = ((vy < 0f) ? 0.8f : 1.6f),
				col = col
			});
		}

		private void StepMotes(float dt)
		{
			for (int num = motes.Count - 1; num >= 0; num--)
			{
				Mote mote = motes[num];
				mote.life -= dt;
				mote.y += mote.vy * dt;
				mote.x += (float)(rng.NextDouble() - 0.5) * 2f * dt;
				if (mote.life <= 0f || mote.y < 0f || mote.y >= 58f)
				{
					motes.RemoveAt(num);
				}
			}
		}

		private void RefreshHud()
		{
			float num = 0f;
			foreach (var lot in lots)
			{
				float item = lot.m3;
				num += item;
			}
			feedBtn.Interactable = lots.Count > 0;
			bool flag = core.eatenM3 <= 0.0;
			rerollBtn.Interactable = pourQueue.Count == 0 && pourCellsLeft == 0 && !evolvePending && (flag || num >= 50000f);
			rerollBtn.Text = ((!(Time.unscaledTime < rerollArmedUntil)) ? "CHANGE CANDY" : (flag ? "SURE? (FREE)" : "SURE? EATS 50K m³"));
			pillBtn.Interactable = pourQueue.Count == 0 && pourCellsLeft == 0 && !evolvePending && core.Stage() > 0 && num >= 5000f;
			pillBtn.Text = ((Time.unscaledTime < pillArmedUntil) ? "SURE? EATS 5K m³" : "SHRINK PILL");
			int num2 = core.Stage();
			stageLabel.Text = $"{StageNames[num2]}  {num2 + 1}/5";
			if (traitLabel != null)
			{
				traitLabel.Text = PetSprite.Describe(petSeed, num2);
			}
			if (stageMeter != null)
			{
				Image bg = stageMeter.Bg;
				bool enabled = (((Behaviour)stageMeter.Fill).enabled = true);
				((Behaviour)bg).enabled = enabled;
				stageMeter.SetFrac(core.StageProgress());
			}
			string text = ((num2 >= 4) ? $"{FormatM3(core.eatenM3)} eaten — prestige {core.PrestigeRollsEarned()}" : ((stageMeter != null) ? (FormatM3(core.eatenM3) + " eaten") : $"{FormatM3(core.eatenM3)} eaten\n{(int)(core.StageProgress() * 100f)}% to {StageNames[num2 + 1]}"));
			string text2;
			if (num > 0f)
			{
				Span<int> span = stackalloc int[8];
				Span<float> span2 = stackalloc float[8];
				int num3 = 0;
				foreach (var lot2 in lots)
				{
					int item2 = lot2.mat;
					float item3 = lot2.m3;
					int num4 = -1;
					for (int i = 0; i < num3; i++)
					{
						if (span[i] == item2)
						{
							num4 = i;
							break;
						}
					}
					if (num4 < 0)
					{
						num4 = num3++;
						span[num4] = item2;
						span2[num4] = 0f;
					}
					span2[num4] += item3;
				}
				int num5 = -1;
				int num6 = -1;
				for (int j = 0; j < num3; j++)
				{
					if (num5 < 0 || span2[j] > span2[num5])
					{
						num6 = num5;
						num5 = j;
					}
					else if (num6 < 0 || span2[j] > span2[num6])
					{
						num6 = j;
					}
				}
				text2 = FormatM3(num) + " gathered";
				if (num5 >= 0)
				{
					text2 += $"\n{(int)(span2[num5] / num * 100f)}% {CarveClass.Name(span[num5])}";
				}
				if (num6 >= 0)
				{
					text2 += $", {(int)(span2[num6] / num * 100f)}% {CarveClass.Name(span[num6])}";
				}
			}
			else
			{
				text2 = ((pourTotalCells > 0) ? "feeding…" : "canister empty");
			}
			if (canisterLabel != null)
			{
				mealLabel.Text = text;
				canisterLabel.Text = text2;
			}
			else
			{
				bool flag3 = ((int)(Time.unscaledTime / 5f) & 1) == 1;
				mealLabel.Text = ((num > 0f || pourTotalCells > 0) ? (text.Split('\n')[0] + "\n" + text2.Replace("\n", " · ")) : (flag3 ? (text.Split('\n')[0] + "\n" + PetSprite.Describe(petSeed, num2)) : text));
			}
		}

		private static string FormatM3(double v)
		{
			if (!(v >= 10000.0))
			{
				return $"{v:0} m³";
			}
			return $"{v / 1000.0:0.#}k m³";
		}

		public void End()
		{
			UserLifetimeStats.SetTankGrid(profileKey, core.SaveGrid());
			UserLifetimeStats.SetPetEaten(profileKey, core.eatenM3);
			UserLifetimeStats.SetPetCanister(profileKey, TerrariumCore.SaveLots(lots));
			TerrariumNet.LocalClosed(ownerNetId);
			tank?.Destroy();
			petLayer?.Destroy();
			foilLayer?.Destroy();
			skinLayer?.Destroy();
			canister?.Destroy();
		}
	}
	internal static class TerrariumNet
	{
		internal class Remote
		{
			public TerrariumCore core;

			public uint seed;

			public int stage;

			public int rev;

			public float petX;

			public float petY;

			public float dispX;

			public float dispY;

			public bool hasDisp;

			public byte pose;

			public float lastSeen;
		}

		private const float PetHz = 4f;

		private const float TankResendSeconds = 5f;

		public const float StaleSeconds = 3f;

		private const byte PoseClosedBit = 64;

		public static readonly Dictionary<uint, Remote> Latest = new Dictionary<uint, Remote>();

		private static float nextPetSendAt;

		private static float nextTankSendAt;

		private static bool localOpen;

		private static readonly TerrariumStateMessage stateMsg = new TerrariumStateMessage();

		private static readonly TerrariumPetMessage petMsg = new TerrariumPetMessage();

		public static void Clear()
		{
			Latest.Clear();
			localOpen = false;
		}

		public static void LocalOpened()
		{
			localOpen = true;
			nextPetSendAt = 0f;
			nextTankSendAt = 0f;
		}

		public static void LocalClosed(uint ownerNetId)
		{
			if (localOpen)
			{
				localOpen = false;
				if (ownerNetId != 0 && NetworkUser.readOnlyInstancesList.Count > 1 && (NetworkServer.active || NetworkClient.active))
				{
					petMsg.Set(ownerNetId, 0f, 0f, 64);
					SendBoth((INetMessage)(object)petMsg);
				}
			}
		}

		public static void StreamLocal(uint ownerNetId, TerrariumCore core, uint seed, float petX, float petY, byte pose)
		{
			if (localOpen && ownerNetId != 0 && NetworkUser.readOnlyInstancesList.Count > 1 && (NetworkServer.active || NetworkClient.active))
			{
				float unscaledTime = Time.unscaledTime;
				if (unscaledTime >= nextTankSendAt)
				{
					nextTankSendAt = unscaledTime + 5f;
					stateMsg.Set(ownerNetId, seed, (byte)core.Stage(), core.SaveGrid());
					SendBoth((INetMessage)(object)stateMsg);
				}
				if (unscaledTime >= nextPetSendAt)
				{
					nextPetSendAt = unscaledTime + 0.25f;
					petMsg.Set(ownerNetId, petX, petY, pose);
					SendBoth((INetMessage)(object)petMsg);
				}
			}
		}

		private static void SendBoth(INetMessage msg)
		{
			if (NetworkServer.active)
			{
				NetMessageExtensions.Send(msg, (NetworkDestination)1);
			}
			else
			{
				NetMessageExtensions.Send(msg, (NetworkDestination)2);
			}
		}

		internal static void StoreState(uint netId, uint seed, byte stage, string grid)
		{
			if (!ArcadeSpectate.IsLocalPlayer(netId))
			{
				if (!Latest.TryGetValue(netId, out var value))
				{
					value = (Latest[netId] = new Remote());
				}
				Remote remote2 = value;
				if (remote2.core == null)
				{
					remote2.core = new TerrariumCore();
				}
				if (!value.core.LoadGrid(grid))
				{
					value.core = null;
					return;
				}
				value.seed = seed;
				value.stage = stage;
				value.rev++;
				value.lastSeen = Time.unscaledTime;
			}
		}

		internal static void StorePet(uint netId, float x, float y, byte pose)
		{
			if (ArcadeSpectate.IsLocalPlayer(netId))
			{
				return;
			}
			Remote value;
			if ((pose & 0x40) != 0)
			{
				Latest.Remove(netId);
			}
			else if (Latest.TryGetValue(netId, out value))
			{
				value.petX = x;
				value.petY = y;
				if (!value.hasDisp)
				{
					value.dispX = x;
					value.dispY = y;
					value.hasDisp = true;
				}
				value.pose = pose;
				value.lastSeen = Time.unscaledTime;
			}
		}
	}
	internal class TerrariumStateMessage : INetMessage, ISerializableObject
	{
		private uint ownerNetId;

		private uint seed;

		private byte stage;

		private string grid = "";

		public void Set(uint ownerNetId, uint seed, byte stage, string grid)
		{
			this.ownerNetId = ownerNetId;
			this.seed = seed;
			this.stage = stage;
			this.grid = grid;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(ownerNetId);
			writer.WritePackedUInt32(seed);
			writer.Write(stage);
			writer.Write(grid ?? "");
		}

		public void Deserialize(NetworkReader reader)
		{
			ownerNetId = reader.ReadPackedUInt32();
			seed = reader.ReadPackedUInt32();
			stage = reader.ReadByte();
			grid = reader.ReadString();
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				if (!HostRelay.Relaying)
				{
					TerrariumNet.StoreState(ownerNetId, seed, stage, grid);
					HostRelay.FanOut((INetMessage)(object)this, ownerNetId);
				}
			}
			else
			{
				TerrariumNet.StoreState(ownerNetId, seed, stage, grid);
			}
		}
	}
	internal class TerrariumPetMessage : INetMessage, ISerializableObject
	{
		private uint ownerNetId;

		private ushort xQ;

		private ushort yQ;

		private byte pose;

		public void Set(uint ownerNetId, float x, float y, byte pose)
		{
			this.ownerNetId = ownerNetId;
			xQ = (ushort)Mathf.Clamp(x * 4f, 0f, 65535f);
			yQ = (ushort)Mathf.Clamp(y * 4f, 0f, 65535f);
			this.pose = pose;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32(ownerNetId);
			writer.Write(xQ);
			writer.Write(yQ);
			writer.Write(pose);
		}

		public void Deserialize(NetworkReader reader)
		{
			ownerNetId = reader.ReadPackedUInt32();
			xQ = reader.ReadUInt16();
			yQ = reader.ReadUInt16();
			pose = reader.ReadByte();
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				if (!HostRelay.Relaying)
				{
					TerrariumNet.StorePet(ownerNetId, (float)(int)xQ / 4f, (float)(int)yQ / 4f, pose);
					HostRelay.FanOut((INetMessage)(object)this, ownerNetId);
				}
			}
			else
			{
				TerrariumNet.StorePet(ownerNetId, (float)(int)xQ / 4f, (float)(int)yQ / 4f, pose);
			}
		}
	}
	internal static class TerrariumSkins
	{
		public const int SkinW = 102;

		public const int SkinH = 84;

		public const int TexW = 204;

		public const int TexH = 168;

		public const int CardTexW = 256;

		public const int CardTexH = 384;

		private const int SlotCount = 4;

		private static readonly int[] slotW = new int[4] { 204, 204, 256, 256 };

		private static readonly int[] slotH = new int[4] { 168, 168, 384, 384 };

		private static readonly string[][] Fragments = new string[2][]
		{
			new string[5] { "voidfog", "voidsurvivorcorrupt", "voidraidfog", "voiddonut", "voidportal" },
			new string[11]
			{
				"chefdisplayfire", "boostedsearfireballflame", "firestaticlarge", "firestatic", "gasolinefire", "tpfire", "flamethrower", "lava", "magma", "flame",
				"fire"
			}
		};

		private static readonly Material[] found = (Material[])(object)new Material[4];

		private static readonly bool[] hunted = new bool[4];

		private static readonly GameObject[] rig = (GameObject[])(object)new GameObject[4];

		private static readonly Camera[] cam = (Camera[])(object)new Camera[4];

		private static readonly Material[] rigMat = (Material[])(object)new Material[4];

		private static readonly RenderTexture[] rt = (RenderTexture[])(object)new RenderTexture[4];

		private static readonly Texture2D[] readTex = (Texture2D[])(object)new Texture2D[2];

		private static readonly Color32[][] pixels = new Color32[2][]
		{
			(Color32[])(object)new Color32[34272],
			(Color32[])(object)new Color32[34272]
		};

		private static readonly int[] sampledFrame = new int[4] { -1, -1, -1, -1 };

		private static readonly bool[] rigFailed = new bool[4];

		private static List<Material> fireCandidates;

		private static int fireIdx = -1;

		public static bool TryGetSkin(PetSprite.Foil foil, out Color32[] rgba)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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)
			rgba = null;
			int num = foil switch
			{
				PetSprite.Foil.ChefFire => 1, 
				PetSprite.Foil.VoidSkin => 0, 
				_ => -1, 
			};
			if (num < 0 || rigFailed[num])
			{
				return false;
			}
			Material val = Hunt(num);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				if (sampledFrame[num] != Time.frameCount)
				{
					if ((Object)(object)rig[num] == (Object)null && !BuildRig(num, val))
					{
						return false;
					}
					sampledFrame[num] = Time.frameCount;
					TickInstance(num);
					cam[num].Render();
					RenderTexture active = RenderTexture.active;
					RenderTexture.active = rt[num];
					readTex[num].ReadPixels(new Rect(0f, 0f, 204f, 168f), 0, 0, false);
					RenderTexture.active = active;
					readTex[num].GetRawTextureData<Color32>().CopyTo(pixels[num]);
				}
				rgba = pixels[num];
				return true;
			}
			catch (Exception e)
			{
				rigFailed[num] = true;
				GoreSystem.WarnThrottled("terrarium skin rig", e);
				return false;
			}
		}

		public static Texture TryGetCardSkin(int kind)
		{
			int num = kind switch
			{
				2 => 3, 
				1 => 2, 
				_ => -1, 
			};
			if (num < 0 || rigFailed[num])
			{
				return null;
			}
			Material val = Hunt(num);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			try
			{
				if ((Object)(object)rig[num] == (Object)null && !BuildRig(num, val))
				{
					return null;
				}
				if (sampledFrame[num] != Time.frameCount)
				{
					sampledFrame[num] = Time.frameCount;
					TickInstance(num);
					cam[num].Render();
				}
				return (Texture)(object)rt[num];
			}
			catch (Exception e)
			{
				rigFailed[num] = true;
				GoreSystem.WarnThrottled("terrarium card skin", e);
				return null;
			}
		}

		private static bool BuildRig(int slot, Material mat)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00e7: 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_010a: 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_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_0179: 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_0199: 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)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: 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_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Expected O, but got Unknown
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			GameObject val = new GameObject($"terrariumSkinRig{slot}");
			val.transform.position = new Vector3(0f, -4000f - (float)slot * 50f, 0f);
			int num = slotW[slot];
			int num2 = slotH[slot];
			GameObject val2 = new GameObject("quad");
			val2.transform.SetParent(val.transform, false);
			Mesh val3 = new Mesh
			{
				name = "terrariumSkinQuad"
			};
			float num3 = 0.5f;
			float num4 = 0.5f * (float)num2 / (float)num;
			val3.vertices = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(0f - num3, 0f - num4, 0f),
				new Vector3(num3, 0f - num4, 0f),
				new Vector3(0f - num3, num4, 0f),
				new Vector3(num3, num4, 0f)
			};
			val3.uv = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(0f, 1f),
				new Vector2(1f, 1f)
			};
			val3.colors32 = (Color32[])(object)new Color32[4]
			{
				new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue),
				new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue),
				new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue),
				new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue)
			};
			val3.triangles = new int[6] { 0, 2, 1, 1, 2, 3 };
			val3.RecalculateNormals();
			val3.RecalculateBounds();
			val2.AddComponent<MeshFilter>().sharedMesh = val3;
			MeshRenderer obj = val2.AddComponent<MeshRenderer>();
			if ((Object)(object)rigMat[slot] != (Object)null)
			{
				Object.Destroy((Object)(object)rigMat[slot]);
			}
			rigMat[slot] = new Material(mat);
			((Renderer)obj).sharedMaterial = rigMat[slot];
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)obj).receiveShadows = false;
			GameObject val4 = new GameObject("cam");
			val4.transform.SetParent(val.transform, false);
			val4.transform.localPosition = new Vector3(0f, 0f, -1f);
			Camera val5 = val4.AddComponent<Camera>();
			((Behaviour)val5).enabled = false;
			val5.orthographic = true;
			val5.orthographicSize = num4;
			val5.aspect = (float)num / (float)num2;
			val5.nearClipPlane = 0.01f;
			val5.farClipPlane = 5f;
			val5.clearFlags = (CameraClearFlags)2;
			val5.backgroundColor = Color.clear;
			val5.allowHDR = false;
			val5.allowMSAA = false;
			val5.useOcclusionCulling = false;
			if ((Object)(object)rt[slot] == (Object)null)
			{
				rt[slot] = new RenderTexture(num, num2, 16)
				{
					filterMode = (FilterMode)1
				};
				if (slot < 2)
				{
					readTex[slot] = new Texture2D(num, num2, (TextureFormat)4, false);
				}
			}
			val5.targetTexture = rt[slot];
			rig[slot] = val;
			cam[slot] = val5;
			ScorchedVoxelsPlugin.Log.LogInfo((object)$"[terrarium] shader skin rig {slot} up: '{((Object)mat).name}' ({((Object)mat.shader).name})");
			return true;
		}

		private static Material Hunt(int slot)
		{
			if (hunted[slot])
			{
				return found[slot];
			}
			hunted[slot] = true;
			try
			{
				Material[] array = Resources.FindObjectsOfTypeAll<Material>();
				string[] array2 = Fragments[slot & 1];
				foreach (string value in array2)
				{
					Material[] array3 = array;
					foreach (Material val in array3)
					{
						if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null))
						{
							string name = ((Object)val).name;
							if (!string.IsNullOrEmpty(name) && name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0 && name.IndexOf("(Instance)", StringComparison.Ordinal) < 0)
							{
								found[slot] = val;
								ScorchedVoxelsPlugin.Log.LogInfo((object)$"[terrarium] shader skin {slot}: '{((Object)val).name}' ({((Object)val.shader).name})");
								return val;
							}
						}
					}
				}
				ScorchedVoxelsPlugin.Log.LogInfo((object)$"[terrarium] shader skin {slot}: no material found; CPU foil stands in");
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("terrarium skin hunt", e);
			}
			return found[slot];
		}

		private static void TickInstance(int slot)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Material val = rigMat[slot];
			if (!((Object)(object)val == (Object)null))
			{
				float num = Time.unscaledTime - Time.time;
				if (!(ScrollBy(val, "_ScrollSpeed", "_Height1", "_Height2", num) | ScrollBy(val, "_CutoffScroll", "_Cloud1Tex", "_Cloud2Tex", num)) && val.HasProperty("_Cloud1Tex"))
				{
					val.SetTextureOffset("_Cloud1Tex", new Vector2(0f, Mathf.Repeat(num * 0.35f, 1f)));
				}
			}
		}

		private static bool ScrollBy(Material m, string speedProp, string texA, string texB, float t)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_00a4: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			if (!m.HasProperty(speedProp))
			{
				return false;
			}
			Vector4 vector = m.GetVector(speedProp);
			bool result = false;
			if (m.HasProperty(texA) && (vector.x != 0f || vector.y != 0f))
			{
				m.SetTextureOffset(texA, new Vector2(Mathf.Repeat(vector.x * t, 1f), Mathf.Repeat(vector.y * t, 1f)));
				result = true;
			}
			if (m.HasProperty(texB) && (vector.z != 0f || vector.w != 0f))
			{
				m.SetTextureOffset(texB, new Vector2(Mathf.Repeat(vector.z * t, 1f), Mathf.Repeat(vector.w * t, 1f)));
				result = true;
			}
			return result;
		}

		public static void DebugCycleFire()
		{
			try
			{
				if (fireCandidates == null)
				{
					fireCandidates = new List<Material>();
					string[] array = new string[6] { "fire", "flame", "lava", "magma", "ember", "heat" };
					Material[] array2 = Resources.FindObjectsOfTypeAll<Material>();
					foreach (Material val in array2)
					{
						if ((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null)
						{
							continue;
						}
						string name = ((Object)val).name;
						if (string.IsNullOrEmpty(name) || name.IndexOf("(Instance)", StringComparison.Ordinal) >= 0)
						{
							continue;
						}
						string[] array3 = array;
						foreach (string value in array3)
						{
							if (name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
							{
								fireCandidates.Add(val);
								break;
							}
						}
					}
					fireCandidates.Sort((Material a, Material b) => string.CompareOrdinal(((Object)a).name, ((Object)b).name));
				}
				if (fireCandidates.Count == 0)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)"[terrarium] fire cycle: no candidates loaded");
					return;
				}
				fireIdx = (fireIdx + 1) % fireCandidates.Count;
				Material val2 = fireCandidates[fireIdx];
				hunted[1] = true;
				found[1] = val2;
				if ((Object)(object)rig[1] != (Object)null)
				{
					Object.Destroy((Object)(object)rig[1]);
				}
				if ((Object)(object)rigMat[1] != (Object)null)
				{
					Object.Destroy((Object)(object)rigMat[1]);
				}
				rig[1] = null;
				cam[1] = null;
				rigMat[1] = null;
				rigFailed[1] = false;
				ScorchedVoxelsPlugin.Log.LogInfo((object)($"[terrarium] fire candidate {fireIdx + 1}/{fireCandidates.Count}: " + "'" + ((Object)val2).name + "' (" + ((Object)val2.shader).name + ")"));
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("terrarium fire cycle", e);
			}
		}

		public static void OnStageStart()
		{
			for (int i = 0; i < 4; i++)
			{
				hunted[i] = false;
				found[i] = null;
				rig[i] = null;
				cam[i] = null;
				if ((Object)(object)rigMat[i] != (Object)null)
				{
					Object.Destroy((Object)(object)rigMat[i]);
				}
				rigMat[i] = null;
				rigFailed[i] = false;
				sampledFrame[i] = -1;
			}
			fireCandidates = null;
			fireIdx = -1;
		}
	}
	internal static class TerrariumStrips
	{
		private class View
		{
			public GameObject go;

			public PixelSurface tank;

			public PixelSurface petLayer;

			public PixelSurface foilLayer;

			public PixelSurface skinLayer;

			public Color32[] skinBuf;

			public int skinOffX;

			public int skinOffY;

			public PetSprite.SetPx set;

			public PetSprite.SetPx setFine;

			public PetSprite.SetPx setSkin;

			public int paintedRev = -1;

			public uint lookSeed;

			public int lookStage = -1;

			public PetSprite.Look look;
		}

		private const float StripH = 88f;

		private const float StripCenterY = -258f;

		private const float CellPx = 3f;

		private static readonly float RootScale = 0.4827586f;

		private static readonly Dictionary<uint, View> views = new Dictionary<uint, View>();

		private static readonly List<uint> prune = new List<uint>();

		public static void Tick()
		{
			float unscaledTime = Time.unscaledTime;
			float dt = Mathf.Min(Time.unscaledDeltaTime, 0.05f);
			prune.Clear();
			foreach (KeyValuePair<uint, View> view2 in views)
			{
				if ((Object)(object)view2.Value.go == (Object)null || !TerrariumNet.Latest.TryGetValue(view2.Key, out var value) || value.core == null || unscaledTime - value.lastSeen > 3f)
				{
					prune.Add(view2.Key);
				}
			}
			foreach (uint item in prune)
			{
				Destroy(views[item]);
				views.Remove(item);
			}
			foreach (KeyValuePair<uint, TerrariumNet.Remote> item2 in TerrariumNet.Latest)
			{
				TerrariumNet.Remote value2 = item2.Value;
				if (value2.core == null || unscaledTime - value2.lastSeen > 3f)
				{
					continue;
				}
				if (!views.TryGetValue(item2.Key, out var value3) || (Object)(object)value3.go == (Object)null)
				{
					if (!LoadingOverlay.TryGetCardTransform(item2.Key, out var t, out var width))
					{
						continue;
					}
					value3 = (views[item2.Key] = Build(t, width));
				}
				Update(value3, value2, dt);
			}
		}

		public static void Clear()
		{
			foreach (View value in views.Values)
			{
				Destroy(value);
			}
			views.Clear();
		}

		private static void Destroy(View v)
		{
			if ((Object)(object)v.go != (Object)null)
			{
				Object.Destroy((Object)(object)v.go);
			}
			v.tank?.Destroy();
			v.petLayer?.Destroy();
			v.foilLayer?.Destroy();
			v.skinLayer?.Destroy();
		}

		private static View Build(Transform card, float cardW)
		{
			//IL_0020: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			UiWindow uiWindow = new UiWindow("tankStrip", card, new Color(0.03f, 0.035f, 0.05f, 0.94f), UiKit.Outline);
			uiWindow.Rect.sizeDelta = new Vector2(cardW, 88f);
			uiWindow.Rect.anchoredPosition = new Vector2(0f, -258f);
			RectTransform val = uiWindow.AddMaskedContent();
			GameObject val2 = new GameObject("tankRoot");
			val2.transform.SetParent((Transform)(object)val, false);
			RectTransform val3 = val2.AddComponent<RectTransform>();
			((Transform)val3).localScale = new Vector3(RootScale, RootScale, 1f);
			View v = new View
			{
				go = uiWindow.Go
			};
			v.tank = new PixelSurface("tank", (Transform)(object)val3, 156, 58, 3f);
			v.skinLayer = new PixelSurface("petSkin", (Transform)(object)val3, 102, 84, 1f);
			v.petLayer = new PixelSurface("pet", (Transform)(object)val3, 34, 28, 3f);
			v.foilLayer = new PixelSurface("petFoil", (Transform)(object)val3, 102, 84, 1f);
			v.set = delegate(int x, int y, byte r2, byte g2, byte b2)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				v.petLayer.Set(x, y, new Color32(r2, g2, b2, byte.MaxValue));
			};
			v.setFine = delegate(int x, int y, byte r2, byte g2, byte b2)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				v.foilLayer.Set(x, y, new Color32(r2, g2, b2, byte.MaxValue));
			};
			v.setSkin = delegate(int cx, int cy, byte r2, byte g2, byte b2)
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				if (v.skinBuf != null)
				{
					for (int i = 0; i < 3; i++)
					{
						for (int j = 0; j < 3; j++)
						{
							int num = cx * 3 + j;
							int num2 = cy * 3 + i;
							if (num >= 0 && num2 >= 0 && num < 102 && num2 < 84)
							{
								v.skinLayer.Set(num, num2, v.skinBuf[(v.skinOffY + num2) * 204 + v.skinOffX + num]);
							}
						}
					}
				}
			};
			return v;
		}

		private static void Update(View v, TerrariumNet.Remote r, float dt)
		{
			//IL_0145: 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_016d: 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_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Clamp(r.stage, 0, 4);
			if (v.paintedRev != r.rev)
			{
				v.paintedRev = r.rev;
				for (int i = 0; i < 58; i++)
				{
					for (int j = 0; j < 156; j++)
					{
						v.tank.Set(j, i, TerrariumGame.CellColor(r.core, j, i));
					}
				}
			}
			if (Mathf.Abs(r.petX - r.dispX) > 24f || Mathf.Abs(r.petY - r.dispY) > 24f)
			{
				r.dispX = r.petX;
				r.dispY = r.petY;
			}
			float num2 = Mathf.Min(1f, dt * 10f);
			r.dispX += (r.petX - r.dispX) * num2;
			r.dispY += (r.petY - r.dispY) * num2;
			if (v.lookSeed != r.seed || v.lookStage != num)
			{
				v.lookSeed = r.seed;
				v.lookStage = num;
				v.look = PetSprite.DeriveLook(r.seed, num);
			}
			v.petLayer.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			v.foilLayer.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			v.skinLayer.Clear(new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			bool flag = TerrariumSkins.TryGetSkin(v.look.foil, out v.skinBuf);
			if (flag)
			{
				v.skinOffX = (int)(Mathf.Clamp01(r.dispX / 156f) * 102f);
				v.skinOffY = (int)(Mathf.Clamp01(r.dispY / 58f) * 84f);
			}
			TerrariumGame.PetState petState = (TerrariumGame.PetState)(r.pose & 7);
			PetSprite.SetPx set = v.set;
			uint seed = r.seed;
			bool sleeping = petState == TerrariumGame.PetState.Sleep;
			bool blink = (r.pose & 0x10) != 0;
			bool wide = (r.pose & 0x20) != 0;
			int facing = (((r.pose & 8) != 0) ? 1 : (-1));
			float unscaledTime = Time.unscaledTime;
			PetSprite.SetPx setFine = v.setFine;
			bool inert = petState == TerrariumGame.PetState.Sleep && num == 0;
			PetSprite.SetPx setSkin = (flag ? v.setSkin : null);
			PetSprite.Paint(set, 17, 4, num, seed, sleeping, blink, wide, facing, 1f, bulge: false, unscaledTime, setFine, flag, null, inert, setSkin);
			float num3 = -234f + Mathf.Round(r.dispX) * 3f;
			float num4 = -87f + Mathf.Round(r.dispY) * 3f;
			Vector2 anchoredPosition = default(Vector2);
			((Vector2)(ref anchoredPosition))..ctor(num3 + 0f, num4 + 30f);
			((Graphic)v.petLayer.Image).rectTransform.anchoredPosition = anchoredPosition;
			((Graphic)v.foilLayer.Image).rectTransform.anchoredPosition = anchoredPosition;
			((Graphic)v.skinLayer.Image).rectTransform.anchoredPosition = anchoredPosition;
			v.tank.Flush();
			v.petLayer.Flush();
			v.foilLayer.Flush();
			v.skinLayer.Flush();
		}
	}
	internal static class TerrariumUnlocks
	{
		private static readonly Random rng = new Random();

		private static NameFxSystem.Tier GateFor(int stage)
		{
			return stage switch
			{
				1 => NameFxSystem.Tier.White, 
				2 => NameFxSystem.Tier.White, 
				_ => NameFxSystem.Tier.Green, 
			};
		}

		public static void GrantStarter(string profileKey)
		{
			try
			{
				if (profileKey != null)
				{
					Grant(profileKey, 0);
				}
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("terrarium unlock", e);
			}
		}

		public static void ReconcileRolls(string profileKey, int stage)
		{
			try
			{
				if (profileKey == null)
				{
					return;
				}
				int num = UserLifetimeStats.PetRolledStage(profileKey);
				if (num >= stage)
				{
					return;
				}
				while (num < stage)
				{
					num++;
					if (num >= 4)
					{
						Grant(profileKey, 13);
						RollWithin(profileKey, NameFxSystem.Tier.Red, 0.0, NameFxSystem.Tier.Green);
					}
					else
					{
						RollWithin(profileKey, GateFor(num), 0.0);
					}
				}
				UserLifetimeStats.SetPetRolledStage(profileKey, num);
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("terrarium unlock", e);
			}
		}

		public static void CheckPrestige(string profileKey, TerrariumCore core)
		{
			try
			{
				if (profileKey != null && core != null)
				{
					int num = core.PrestigeRollsEarned();
					int num2 = UserLifetimeStats.PetPrestigeUsed(profileKey);
					bool flag = false;
					while (num2 < num)
					{
						num2++;
						flag = true;
						RollWithin(profileKey, NameFxSystem.Tier.Lunar, 1.0 / 6.0);
					}
					if (flag)
					{
						UserLifetimeStats.SetPetPrestigeUsed(profileKey, num2);
					}
				}
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("terrarium prestige", e);
			}
		}

		private static void RollWithin(string profileKey, NameFxSystem.Tier maxTier, double voidChance, NameFxSystem.Tier minTier = NameFxSystem.Tier.White)
		{
			IReadOnlyList<int> owned = UserLifetimeStats.UnlockedNameFx(profileKey);
			if (voidChance > 0.0 && !Owns(14) && rng.NextDouble() < voidChance)
			{
				Grant(profileKey, 14);
				return;
			}
			List<int> list = new List<int>();
			for (int i = 0; i < NameFxSystem.Table.Length; i++)
			{
				if ((int)NameFxSystem.Table[i].tier <= (int)maxTier && (int)NameFxSystem.Table[i].tier >= (int)minTier && i != 14 && !Owns(i))
				{
					list.Add(i);
				}
			}
			if (list.Count != 0)
			{
				Grant(profileKey, list[rng.Next(list.Count)]);
			}
			bool Owns(int idx)
			{
				for (int j = 0; j < owned.Count; j++)
				{
					if (owned[j] == idx)
					{
						return true;
					}
				}
				return UserLifetimeStats.PendingContains(profileKey, 2, idx);
			}
		}

		private static void Grant(string profileKey, int idx)
		{
			if (idx < 0 || idx >= NameFxSystem.Table.Length)
			{
				return;
			}
			IReadOnlyList<int> readOnlyList = UserLifetimeStats.UnlockedNameFx(profileKey);
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				if (readOnlyList[i] == idx)
				{
					return;
				}
			}
			if (!UserLifetimeStats.PendingContains(profileKey, 2, idx))
			{
				UserLifetimeStats.EnqueuePending(profileKey, 2, idx);
				ScorchedVoxelsPlugin.Log.LogInfo((object)("[terrarium] name effect won: " + NameFxSystem.Table[idx].name + " — queued for the reveal"));
			}
		}
	}
	internal static class WeaponIcons
	{
		private static readonly string[] Keys = new string[9] { "RoR2/Base/CommandMissile/texMissileRackIcon.png", "RoR2/Base/StickyBomb/texStickyBombIcon.png", "RoR2/Base/ExplodeOnDeath/texWilloWispIcon.png", "RoR2/Base/Meteor/texMeteorIcon.png", "RoR2/DLC1/Molotov/texMolotovIcon.png", "RoR2/Base/Lightning/texCapacitorIcon.png", "RoR2/Base/Crowbar/texCrowbarIcon.png", "RoR2/Base/Blackhole/texGravCubeIcon.png", "RoR2/Base/Bear/texBearIcon.png" };

		private static readonly Sprite[] sprites = (Sprite[])(object)new Sprite[Keys.Length];

		private static bool loading;

		public static int Version { get; private set; }

		public static void EnsureLoading()
		{
			//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)
			if (loading)
			{
				return;
			}
			loading = true;
			for (int i = 0; i < Keys.Length; i++)
			{
				int captured = i;
				try
				{
					AsyncOperationHandle<Sprite> val = Addressables.LoadAssetAsync<Sprite>((object)Keys[i]);
					val.Completed += delegate(AsyncOperationHandle<Sprite> op)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_0008: Invalid comparison between Unknown and I4
						if ((int)op.Status == 1 && (Object)(object)op.Result != (Object)null)
						{
							sprites[captured] = op.Result;
							Version++;
						}
					};
				}
				catch (Exception ex)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] weapon icon '" + Keys[captured] + "': " + ex.Message));
				}
			}
		}

		public static Sprite Get(int weapon)
		{
			if (weapon < 0 || weapon >= sprites.Length)
			{
				return null;
			}
			return sprites[weapon];
		}
	}
	internal class WormsGame : IMiniGame
	{
		private enum Weapon
		{
			Bazooka,
			Grenade,
			Cluster,
			Meteors,
			Molotov,
			Thunderbolt,
			Drill,
			GravCube,
			Bunker
		}

		internal class MatchConfig
		{
			public uint matchId;

			public uint seed;

			public uint[] ids;

			public byte[] colorways;
		}

		private class Unit
		{
			public uint ownerNetId;

			public int colorway;

			public int xQ;

			public int yQ;

			public int hp = 100;

			public bool alive = true;

			public int[] ammo = (int[])KitAmmo.Clone();

			public int aimAngleDeg = 60;

			public int aimPower = 70;

			public bool facingRight = true;

			public Image image;

			public UiMeter hpBar;
		}

		private class Shell
		{
			public int xQ;

			public int yQ;

			public int vxQ;

			public int vyQ;

			public Weapon weapon;

			public bool drilling;

			public int drilled;

			public int drillAir;

			public int fuse;

			public int arm;

			public bool bomblet;

			public int ignoreUnit = -1;

			public Image image;
		}

		private enum Phase
		{
			Aiming,
			Flight,
			Won
		}

		private struct FireCell
		{
			public int x;

			public int y;

			public int life;
		}

		private class Fx
		{
			public float x;

			public float y;

			public float vx;

			public float vy;

			public float life;

			public float maxLife;

			public float size;

			public bool gravity;

			public Color color;

			public Image image;
		}

		private const int Q = 65536;

		private const int TickHz = 60;

		private const float CellPx = 2f;

		private const int GravityQ = 546;

		private const int WindUnitQ = 20;

		private const int MaxWindLevel = 7;

		private const int MuzzleQ = 144000;

		private static readonly string[] WeaponNames = new string[9] { "BAZOOKA", "GRENADE", "CLUSTER", "METEORS", "MOLOTOV", "BOLT", "DRILL", "CUBE", "BUNKER" };

		private static readonly int[] CarveR = new int[9] { 10, 9, 5, 7, 6, 0, 7, 12, 0 };

		private static readonly int[] DmgR = new int[9] { 13, 12, 7, 10, 9, 8, 10, 14, 0 };

		private static readonly int[] Dmg = new int[9] { 75, 70, 25, 40, 30, 55, 50, 35, 0 };

		private static readonly int[] Wind16 = new int[9] { 16, 3, 16, 6, 12, 0, 0, 4, 0 };

		private static readonly int[] KitAmmo = new int[9] { -1, -1, 2, 1, 2, 1, 1, 1, 0 };

		private const int GrenadeFuseTicks = 180;

		private const int ClusterBomblets = 5;

		private const int FireLifeTicks = 150;

		private const int FireBurnEvery = 12;

		private const int FireDmgEvery = 15;

		private const int DrillMaxCells = 90;

		private const int DrillBurstAirTicks = 12;

		private const int BoltDepth = 14;

		private const int CubePullR = 26;

		private const int BombletFuseTicks = 360;

		private const int AirstrikeShells = 3;

		private const int UnitHp = 100;

		private const int CratePercent = 25;

		private const int BunkerTall = 14;

		private const int BunkerLip = 6;

		internal const float TurnTimeoutSeconds = 45f;

		private static readonly int[] SinQ = new int[257]
		{
			0, 402, 804, 1206, 1608, 2010, 2412, 2814, 3216, 3617,
			4019, 4420, 4821, 5222, 5623, 6023, 6424, 6824, 7224, 7623,
			8022, 8421, 8820, 9218, 9616, 10014, 10411, 10808, 11204, 11600,
			11996, 12391, 12785, 13180, 13573, 13966, 14359, 14751, 15143, 15534,
			15924, 16314, 16703, 17091, 17479, 17867, 18253, 18639, 19024, 19409,
			19792, 20175, 20557, 20939, 21320, 21699, 22078, 22457, 22834, 23210,
			23586, 23961, 24335, 24708, 25080, 25451, 25821, 26190, 26558, 26925,
			27291, 27656, 28020, 28383, 28745, 29106, 29466, 29824, 30182, 30538,
			30893, 31248, 31600, 31952, 32303, 32652, 33000, 33347, 33692, 34037,
			34380, 34721, 35062, 35401, 35738, 36075, 36410, 36744, 37076, 37407,
			37736, 38064, 38391, 38716, 39040, 39362, 39683, 40002, 40320, 40636,
			40951, 41264, 41576, 41886, 42194, 42501, 42806, 43110, 43412, 43713,
			44011, 44308, 44604, 44898, 45190, 45480, 45769, 46056, 46341, 46624,
			46906, 47186, 47464, 47741, 48015, 48288, 48559, 48828, 49095, 49361,
			49624, 49886, 50146, 50404, 50660, 50914, 51166, 51417, 51665, 51911,
			52156, 52398, 52639, 52878, 53114, 53349, 53581, 53812, 54040, 54267,
			54491, 54714, 54934, 55152, 55368, 55582, 55794, 56004, 56212, 56418,
			56621, 56823, 57022, 57219, 57414, 57607, 57798, 57986, 58172, 58356,
			58538, 58718, 58896, 59071, 59244, 59415, 59583, 59750, 59914, 60075,
			60235, 60392, 60547, 60700, 60851, 60999, 61145, 61288, 61429, 61568,
			61705, 61839, 61971, 62101, 62228, 62353, 62476, 62596, 62714, 62830,
			62943, 63054, 63162, 63268, 63372, 63473, 63572, 63668, 63763, 63854,
			63944, 64031, 64115, 64197, 64277, 64354, 64429, 64501, 64571, 64639,
			64704, 64766, 64827, 64884, 64940, 64993, 65043, 65091, 65137, 65180,
			65220, 65259, 65294, 65328, 65358, 65387, 65413, 65436, 65457, 65476,
			65492, 65505, 65516, 65525, 65531, 65535, 65536
		};

		private static readonly int[] GaussQ = new int[97]
		{
			65536, 65472, 65280, 64963, 64520, 63955, 63272, 62474, 61565, 60552,
			59439, 58232, 56939, 55565, 54119, 52608, 51039, 49421, 47760, 46065,
			44344, 42603, 40851, 39095, 37341, 35597, 33867, 32159, 30477, 28827,
			27213, 25639, 24109, 22627, 21193, 19812, 18485, 17213, 15998, 14839,
			13737, 12692, 11704, 10772, 9894, 9071, 8299, 7579, 6907, 6283,
			5704, 5168, 4674, 4218, 3800, 3416, 3065, 2745, 2453, 2188,
			1948, 1731, 1535, 1359, 1200, 1058, 931, 818, 717, 627,
			547, 477, 415, 360, 312, 270, 233, 200, 172, 148,
			127, 108, 92, 78, 67, 57, 48, 40, 34, 29,
			24, 20, 17, 14, 12, 10, 8
		};

		private ArcadeContext ctx;

		private PixelSurface surface;

		private string profileKey;

		private MatchConfig match;

		private readonly List<WormsShot> appliedShots = new List<WormsShot>();

		private readonly Queue<WormsShot> canonQueue = new Queue<WormsShot>();

		private bool awaitingEcho;

		private float awaitingEchoSince;

		private byte[] solid;

		private Color32[] backdrop;

		private ArcadeThemes.Theme theme;

		private Color32 crustCol;

		private Color32 dirtDeep;

		private Color32 dirtMid;

		private Color32 masonryDark;

		private Color32 backBase;

		private Color32 backDark;

		private int W;

		private int H;

		private int spawnCeil;

		private uint rngState;

		private readonly List<Unit> units = new List<Unit>();

		private readonly List<Shell> shells = new List<Shell>();

		private readonly List<FireCell> fires = new List<FireCell>();

		private int fireClock;

		private readonly List<int> boltCells = new List<int>();

		private float boltRepaintAt;

		private readonly List<Image> dotPool = new List<Image>();

		private readonly List<Image> shellPool = new List<Image>();

		private Phase phase;

		private int turnUnit;

		private int windLevel;

		private Weapon weapon;

		private float tickCarry;

		private int targetX;

		private int targetY;

		private int crateX = -1;

		private int crateY;

		private Weapon crateLoot;

		private GameObject crateGo;

		private RectTransform crateRect;

		private UiKit.Btn[] weaponBtns;

		private UiKit.Label turnLabel;

		private string turnLabelBase = "";

		private float turnStartedAt;

		private int shownAutoPass = -1;

		private UiKit.Label windLabel;

		private RectTransform windArrow;

		private Image windArrowImg;

		private UiKit.Label message;

		private RectTransform fieldRect;

		private float fieldW;

		private float fieldH;

		private RectTransform dialRect;

		private RectTransform needle;

		private Image needleImg;

		private RectTransform shootRect;

		private Image shootFace;

		private UiKit.Label shootLabel;

		private UiMeter powerBar;

		private bool charging;

		private float chargeT;

		private const float LeftColW = 170f;

		private const float RightColW = 140f;

		private const float PowerBarW = 148f;

		private const float ChargeSpeed = 1.15f;

		private const byte CellAir = 0;

		private const byte CellDirt = 1;

		private const byte CellMasonry = 2;

		private const byte CellFresh = 3;

		private static readonly Color32 ScorchCol = new Color32((byte)58, (byte)44, (byte)34, byte.MaxValue);

		private static readonly Color32 FreshDirt = new Color32((byte)146, (byte)120, (byte)82, byte.MaxValue);

		private static readonly Color32 FireCol = new Color32((byte)244, (byte)150, (byte)38, byte.MaxValue);

		private readonly List<Fx> fxLive = new List<Fx>();

		private readonly List<Image> fxPool = new List<Image>();

		private const int FxPoolSize = 28;

		private float nextTrailAt;

		private static readonly string[] ShortNames = new string[9] { "BAZ", "NAD", "CLU", "MTR", "MOL", "BLT", "DRL", "CUB", "BNK" };

		private Image[] weaponIcons;

		private UiKit.Label[] nameLabels;

		private UiKit.Label[] ammoLabels;

		private Image selectFrame;

		private int iconsSeen = -1;

		private static Sprite dialSprite;

		private static readonly Weapon[] CrateLootPool = new Weapon[6]
		{
			Weapon.Meteors,
			Weapon.Molotov,
			Weapon.Thunderbolt,
			Weapon.Drill,
			Weapon.GravCube,
			Weapon.Bunker
		};

		private static uint dugBankMatchId;

		private static int dugBankedShots;

		private bool dugCreditArmed;

		internal uint MatchId => match?.matchId ?? 0;

		internal int AppliedShotCount => appliedShots.Count;

		internal int KnownShotCount => appliedShots.Count + canonQueue.Count;

		internal uint CurrentTurnOwner
		{
			get
			{
				if (turnUnit >= units.Count)
				{
					return 0u;
				}
				return units[turnUnit].ownerNetId;
			}
		}

		internal bool MatchOver => phase == Phase.Won;

		internal bool InFlight => phase == Phase.Flight;

		internal static bool ValidWeaponByte(byte w)
		{
			return w < WeaponNames.Length;
		}

		private static int FloorCell(int q)
		{
			return q >> 16;
		}

		private static int SinTurnQ16(int a)
		{
			a &= 0xFFFF;
			int num = a >> 14;
			int num2 = a & 0x3FFF;
			if ((num & 1) != 0)
			{
				num2 = 16384 - num2;
			}
			int num3 = num2 >> 6;
			int num4 = SinQ[num3];
			if ((num2 & 0x3F) != 0)
			{
				num4 += (SinQ[num3 + 1] - num4) * (num2 & 0x3F) / 64;
			}
			if (num < 2)
			{
				return num4;
			}
			return -num4;
		}

		private static int CosTurnQ16(int a)
		{
			return SinTurnQ16(a + 16384);
		}

		private static int SinDegQ16(int deg)
		{
			return SinTurnQ16(deg * 8192 / 45);
		}

		private static int CosDegQ16(int deg)
		{
			return SinTurnQ16(deg * 8192 / 45 + 16384);
		}

		private static int GaussExpQ16(int i)
		{
			if (i < 0)
			{
				i = -i;
			}
			if (i >= GaussQ.Length)
			{
				return 0;
			}
			return GaussQ[i];
		}

		public void Start(ArcadeContext c)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_013a: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: 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)
			ctx = c;
			match = c.wormsMatch;
			rngState = ((match != null) ? (match.seed | 1) : ((ctx.seed ^ (uint)Environment.TickCount) | 1));
			profileKey = ArcadeLocal.ProfileKey();
			fieldW = ctx.width - 170f - 140f - 12f;
			fieldH = ctx.height;
			W = Mathf.FloorToInt(fieldW / 2f);
			H = Mathf.FloorToInt(fieldH / 2f);
			solid = new byte[W * H];
			backdrop = (Color32[])(object)new Color32[W * H];
			theme = ArcadeThemes.RollTheme(ref rngState, ArcadeTheming.DestinationScene);
			DeriveWormsShades();
			GameObject val = new GameObject("field");
			val.transform.SetParent((Transform)(object)ctx.panel, false);
			fieldRect = val.AddComponent<RectTransform>();
			fieldRect.pivot = new Vector2(0f, 0.5f);
			fieldRect.anchorMin = new Vector2(0f, 0.5f);
			fieldRect.anchorMax = new Vector2(0f, 0.5f);
			fieldRect.sizeDelta = new Vector2(fieldW, fieldH);
			fieldRect.anchoredPosition = new Vector2(176f, 0f);
			surface = new PixelSurface("wormsTerrain", (Transform)(object)fieldRect, W, H, 2f);
			((Graphic)surface.Image).rectTransform.anchoredPosition = Vector2.zero;
			GenerateTerrain();
			SpawnUnits();
			BuildSidePanel();
			windLevel = NextWind();
			phase = Phase.Aiming;
			BeginTurn(0);
		}

		private uint NextRng()
		{
			return ArcadeRng.Step(ref rngState);
		}

		private int RngRange(int minIncl, int maxExcl)
		{
			return minIncl + (int)(NextRng() % (uint)(maxExcl - minIncl));
		}

		private int NextWind()
		{
			return RngRange(-7, 8);
		}

		private void GenerateTerrain()
		{
			int num = RngRange(0, 5);
			spawnCeil = H;
			int num2 = RngRange(7, 15);
			int num3 = RngRange(3, 8);
			int num4 = RngRange(1, 4);
			int num5 = RngRange(0, 628);
			int num6 = RngRange(0, 628);
			int num7 = RngRange(0, 628);
			int num8 = H * 42 / 100;
			int[] array = new int[W];
			for (int i = 0; i < W; i++)
			{
				int num9 = num8 + num2 * SinTurnQ16(i * 209 + num5 * 104) / 65536 + num3 * SinTurnQ16(i * 553 + num6 * 104) / 65536 + num4 * SinTurnQ16(i * 1773 + num7 * 104) / 65536;
				switch (num)
				{
				case 1:
					num9 += 18 * CosTurnQ16(i * 65536 / W - 32768) / 65536 + 6;
					break;
				case 2:
				{
					int num10 = W * 11 / 100;
					num9 += 20 * (GaussExpQ16((i - W / 4) * 32 / num10) + GaussExpQ16((i - W * 3 / 4) * 32 / num10)) / 65536 - 5;
					break;
				}
				case 3:
					num9 = num9 * 2 / 3;
					break;
				}
				array[i] = Mathf.Clamp(num9, 8, H - 26);
				for (int j = 0; j < array[i]; j++)
				{
					solid[j * W + i] = 1;
				}
			}
			switch (num)
			{
			case 3:
			{
				int num13 = 2 + RngRange(0, 2);
				for (int m = 0; m < num13; m++)
				{
					int num14 = W * (m * 2 + 1) / (num13 * 2) + RngRange(-14, 15);
					int num15 = num8 + 14 + RngRange(0, 12);
					int num16 = RngRange(16, 26);
					int num17 = RngRange(5, 8);
					for (int n = -num17; n <= num17; n++)
					{
						for (int num18 = -num16; num18 <= num16; num18++)
						{
							if (num18 * num18 * num17 * num17 + n * n * num16 * num16 <= num16 * num16 * num17 * num17)
							{
								int num19 = num14 + num18;
								int num20 = num15 + n;
								if (num19 >= 0 && num19 < W && num20 >= 0 && num20 < H)
								{
									solid[num20 * W + num19] = 1;
								}
							}
						}
					}
				}
				break;
			}
			case 4:
			{
				int num11 = H - RngRange(4, 7);
				for (int k = 0; k < W; k++)
				{
					int num12 = num11 - 3 * SinTurnQ16(k * 469 + num6 * 104) / 65536 - RngRange(0, 2);
					for (int l = num12; l < H; l++)
					{
						solid[l * W + k] = 1;
					}
					spawnCeil = Mathf.Min(spawnCeil, num12 - 2);
				}
				break;
			}
			}
			if (RngRange(0, 100) < 65)
			{
				int num21 = 1 + RngRange(0, 2);
				for (int num22 = 0; num22 < num21; num22++)
				{
					int num23 = RngRange(W / 5, W * 4 / 5);
					int num24 = RngRange(6, 10);
					int num25 = RngRange(12, 20);
					int num26 = SurfaceScan(num23 + num24 / 2, spawnCeil);
					for (int num27 = 0; num27 < num24; num27++)
					{
						for (int num28 = 0; num28 < num25; num28++)
						{
							int num29 = num23 + num27;
							int num30 = num26 + num28;
							if (num29 >= 2 && num29 < W - 2 && num30 >= 1 && num30 < H - 2 && (num30 <= num26 + 2 || num30 >= num26 + num25 - 3 || num27 <= 1 || num27 >= num24 - 2))
							{
								solid[num30 * W + num29] = 2;
							}
						}
					}
					int num31 = num23 + ((num23 < W / 2) ? (num24 - 1) : 0);
					for (int num32 = 1; num32 <= 5; num32++)
					{
						if (num31 >= 0 && num31 < W && num26 + num32 < H)
						{
							solid[(num26 + num32) * W + num31] = 0;
						}
					}
				}
			}
			for (int num33 = 0; num33 < 2; num33++)
			{
				int cx = RngRange(W / 6, W * 5 / 6);
				int cy = RngRange(8, num8 - 6);
				int r = RngRange(6, 11);
				CarveCircle(cx, cy, r, rim: false);
			}
			BakeBackdrop();
			RedrawAllTerrain();
		}

		private void BakeBackdrop()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0030: 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_0078: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_016f: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = new byte[1760];
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Color32 val = backBase;
					if (ArcadeThemes.StrataBand(j, i, 3, 7, drift: true, 11, 3))
					{
						val = backDark;
					}
					if ((theme.dress & 2) != 0 && ArcadeThemes.AccentSeed(j, i, 331))
					{
						val = ArcadeThemes.Scale(theme.cap, 0.5f);
					}
					backdrop[i * W + j] = val;
				}
			}
			int num2;
			for (int k = 10 + RngRange(0, 20); k < W - 30; k += num2 + 14 + RngRange(0, 30))
			{
				int num = DecorStamps.Raster(RngRange(0, 16), array, ref rngState);
				num2 = num >> 8;
				int num3 = num & 0xFF;
				int num4 = 2 + RngRange(0, 8);
				for (int l = 0; l < num2; l++)
				{
					for (int m = 0; m < num3; m++)
					{
						byte b = array[m * 40 + l];
						if (b != 0)
						{
							int num5 = k + l;
							int num6 = num4 + m;
							if (num5 >= 0 && num5 < W && num6 >= 0 && num6 < H)
							{
								backdrop[num6 * W + num5] = ((b == 3) ? ArcadeThemes.Scale(theme.cap, 0.42f) : ArcadeThemes.Scale(theme.mid, (b == 1) ? 0.3f : 0.38f));
							}
						}
					}
				}
			}
		}

		private void DeriveWormsShades()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_0094: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			dirtDeep = ArcadeThemes.Scale(theme.mid, 0.82f);
			dirtMid = theme.mid;
			crustCol = (((theme.dress & 1) != 0) ? theme.cap : ArcadeThemes.Scale(theme.slab, 1f));
			masonryDark = ArcadeThemes.Scale(theme.slab, 0.82f);
			backBase = ArcadeThemes.Scale(theme.deep, 0.55f);
			backDark = ArcadeThemes.Scale(theme.deep, 0.42f);
		}

		private bool Solid(int x, int y)
		{
			if (x >= 0 && x < W && y >= 0 && y < H)
			{
				return solid[y * W + x] != 0;
			}
			return false;
		}

		private Color32 TerrainColor(int x, int y)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_0109: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			switch ((byte)((x >= 0 && x < W && y >= 0 && y < H) ? solid[y * W + x] : 0))
			{
			case 0:
				return backdrop[y * W + x];
			case 2:
				if (!((y % 3 == 2) ^ ((x & 4) != 0)))
				{
					return theme.slab;
				}
				return masonryDark;
			case 3:
				return FreshDirt;
			default:
				if (!Solid(x, y + 1) || !Solid(x, y + 2))
				{
					return crustCol;
				}
				if ((theme.dress & 8) != 0 && ArcadeThemes.AccentSeed(x, y, 127))
				{
					return ArcadeThemes.Scale(theme.cap, 0.8f);
				}
				if ((theme.dress & 4) != 0 && ArcadeThemes.StrataBand(x, y, 3, 1, drift: false, 9, 2))
				{
					return ArcadeThemes.Scale(dirtDeep, 0.85f);
				}
				if ((ArcadeThemes.DressHash(x, y) & 7) >= 3)
				{
					return dirtMid;
				}
				return dirtDeep;
			}
		}

		private void RedrawAllTerrain()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					surface.Set(j, i, TerrainColor(j, i));
				}
			}
		}

		private void RepaintCell(int x, int y)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (x >= 0 && x < W && y >= 0 && y < H)
			{
				surface.Set(x, y, TerrainColor(x, y));
			}
		}

		private int CarveCircle(int cx, int cy, int r, bool rim)
		{
			//IL_007e: 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)
			int num = 0;
			int num2 = r + 2;
			for (int i = Mathf.Max(0, cy - num2); i <= Mathf.Min(H - 1, cy + num2); i++)
			{
				for (int j = Mathf.Max(0, cx - num2); j <= Mathf.Min(W - 1, cx + num2); j++)
				{
					int num3 = j - cx;
					int num4 = i - cy;
					int num5 = num3 * num3 + num4 * num4;
					if (num5 <= r * r)
					{
						if (solid[i * W + j] != 0)
						{
							num++;
						}
						solid[i * W + j] = 0;
						surface.Set(j, i, backdrop[i * W + j]);
					}
					else if (rim && num5 <= num2 * num2 && solid[i * W + j] != 0)
					{
						surface.Set(j, i, ScorchCol);
					}
				}
			}
			return num;
		}

		private void SpawnUnits()
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: 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_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>();
			List<uint> list2 = new List<uint>();
			int num;
			if (match != null)
			{
				num = match.ids.Length;
				for (int i = 0; i < num; i++)
				{
					list2.Add(match.ids[i]);
					list.Add(match.colorways[i]);
				}
			}
			else
			{
				num = 3;
				foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
				{
					if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
					{
						list.AddRange(UserLifetimeStats.ArcadeColors(UserLifetimeStats.ProfileKey(readOnlyInstances)));
						break;
					}
				}
				int[] array = new int[4] { 0, 8, 4, 11 };
				foreach (int item in array)
				{
					if (list.Count < 3 && !list.Contains(item))
					{
						list.Add(item);
					}
				}
				for (int k = 0; k < num; k++)
				{
					list2.Add(0u);
				}
			}
			for (int l = 0; l < num; l++)
			{
				int num2 = W * (l * 2 + 1) / (num * 2) + RngRange(-6, 7);
				int num3 = SurfaceYAt(num2);
				Unit unit = new Unit
				{
					ownerNetId = list2[l],
					colorway = list[l],
					xQ = num2 * 65536,
					yQ = num3 * 65536
				};
				GameObject val = new GameObject($"worm{l}");
				val.transform.SetParent((Transform)(object)fieldRect, false);
				unit.image = val.AddComponent<Image>();
				((Graphic)unit.image).raycastTarget = false;
				RectTransform rectTransform = ((Graphic)unit.image).rectTransform;
				rectTransform.pivot = new Vector2(0.5f, 0f);
				rectTransform.anchorMin = new Vector2(0f, 0.5f);
				rectTransform.anchorMax = new Vector2(0f, 0.5f);
				rectTransform.sizeDelta = CommandoSprites.CommandoSize * 2f;
				unit.hpBar = new UiMeter("hpBg", (Transform)(object)fieldRect, new Vector2(18f, 4f), new Color(0f, 0f, 0f, 0.6f), UiKit.Green);
				((Graphic)unit.hpBar.Bg).raycastTarget = false;
				unit.hpBar.Rect.pivot = new Vector2(0.5f, 0f);
				unit.hpBar.Rect.anchorMin = new Vector2(0f, 0.5f);
				unit.hpBar.Rect.anchorMax = new Vector2(0f, 0.5f);
				units.Add(unit);
			}
			foreach (Unit unit2 in units)
			{
				PlaceUnitVisual(unit2);
			}
		}

		private int SurfaceYAt(int x)
		{
			return SurfaceScan(x, spawnCeil);
		}

		private int SurfaceScan(int x, int below)
		{
			for (int num = Mathf.Min(below, H) - 1; num > 0; num--)
			{
				if (Solid(x, num))
				{
					return num + 1;
				}
			}
			return 1;
		}

		private void PlaceUnitVisual(Unit u)
		{
			//IL_0042: 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_00ad: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)u.xQ / 65536f * 2f;
			float num2 = (float)u.yQ / 65536f * 2f - fieldH * 0.5f;
			((Graphic)u.image).rectTransform.anchoredPosition = new Vector2(num, num2);
			u.image.sprite = CommandoSprites.CommandoFrame(u.colorway, 0f);
			((Transform)((Graphic)u.image).rectTransform).localScale = new Vector3(u.facingRight ? 1f : (-1f), 1f, 1f);
			u.hpBar.Rect.anchoredPosition = new Vector2(num, num2 + 24f);
			u.hpBar.SetFrac(Mathf.Clamp01((float)u.hp / 100f));
			((Graphic)u.hpBar.Fill).color = (Color)((u.hp > 50) ? UiKit.Green : ((u.hp > 25) ? UiKit.Gold : new Color(0.85f, 0.3f, 0.2f)));
		}

		private void SpawnFx(float cellX, float cellY, float vx, float vy, float life, float size, Color color, bool gravity)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: 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_00a2: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			Image val = null;
			foreach (Image item in fxPool)
			{
				if (!((Component)item).gameObject.activeSelf)
				{
					val = item;
					break;
				}
			}
			if ((Object)(object)val == (Object)null && fxPool.Count < 28)
			{
				val = UiKit.CreateImage($"fx{fxPool.Count}", (Transform)(object)fieldRect, Color.white);
				((Graphic)val).raycastTarget = false;
				((Graphic)val).rectTransform.pivot = new Vector2(0.5f, 0.5f);
				((Graphic)val).rectTransform.anchorMin = new Vector2(0f, 0.5f);
				((Graphic)val).rectTransform.anchorMax = new Vector2(0f, 0.5f);
				fxPool.Add(val);
			}
			if (!((Object)(object)val == (Object)null))
			{
				((Component)val).gameObject.SetActive(true);
				((Graphic)val).color = color;
				((Graphic)val).rectTransform.sizeDelta = new Vector2(size, size);
				((Graphic)val).rectTransform.anchoredPosition = new Vector2(cellX * 2f, cellY * 2f - fieldH * 0.5f);
				fxLive.Add(new Fx
				{
					x = cellX * 2f,
					y = cellY * 2f,
					vx = vx,
					vy = vy,
					life = life,
					maxLife = life,
					size = size,
					color = color,
					gravity = gravity,
					image = val
				});
			}
		}

		private void TickFx(float dt)
		{
			//IL_00e5: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			for (int num = fxLive.Count - 1; num >= 0; num--)
			{
				Fx fx = fxLive[num];
				fx.life -= dt;
				if (fx.life <= 0f)
				{
					((Component)fx.image).gameObject.SetActive(false);
					fxLive.RemoveAt(num);
				}
				else
				{
					if (fx.gravity)
					{
						fx.vy -= 260f * dt;
					}
					fx.x += fx.vx * dt;
					fx.y += fx.vy * dt;
					float num2 = fx.life / fx.maxLife;
					((Graphic)fx.image).color = new Color(fx.color.r, fx.color.g, fx.color.b, fx.color.a * num2);
					((Graphic)fx.image).rectTransform.sizeDelta = new Vector2(fx.size, fx.size) * (0.5f + 0.5f * num2);
					((Graphic)fx.image).rectTransform.anchoredPosition = new Vector2(fx.x, fx.y - fieldH * 0.5f);
				}
			}
			if (phase != Phase.Flight || !(Time.unscaledTime >= nextTrailAt))
			{
				return;
			}
			nextTrailAt = Time.unscaledTime + 0.05f;
			foreach (Shell shell in shells)
			{
				bool flag = shell.weapon == Weapon.Meteors || shell.weapon == Weapon.Molotov;
				SpawnFx((float)shell.xQ / 65536f, (float)shell.yQ / 65536f, Random.Range(-6f, 6f), Random.Range(-2f, 8f), flag ? 0.4f : 0.3f, flag ? 5f : 3f, flag ? new Color(1f, 0.55f, 0.2f, 0.8f) : new Color(0.8f, 0.8f, 0.8f, 0.45f), gravity: false);
			}
		}

		private void FxExplosion(int cx, int cy, int r, Weapon wp)
		{
			//IL_0062: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = wp == Weapon.Meteors || wp == Weapon.Molotov;
			SpawnFx(cx, cy, 0f, 0f, 0.12f, (float)r * 2f * 2.4f, flag ? new Color(1f, 0.7f, 0.3f, 0.9f) : new Color(1f, 0.95f, 0.8f, 0.9f), gravity: false);
			SpawnFx(cx, cy, 0f, 12f, 0.55f, (float)r * 2f * 1.6f, new Color(0.45f, 0.42f, 0.4f, 0.5f), gravity: false);
			for (int i = 0; i < 7; i++)
			{
				SpawnFx(cx, cy, Random.Range(-70f, 70f), Random.Range(40f, 130f), Random.Range(0.35f, 0.7f), Random.Range(2f, 4f), Color32.op_Implicit(new Color32(dirtMid.r, dirtMid.g, dirtMid.b, byte.MaxValue)), gravity: true);
			}
		}

		private void FxImplosion(int cx, int cy)
		{
			//IL_0098: 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)
			for (int i = 0; i < 10; i++)
			{
				float num = Random.Range(0f, MathF.PI * 2f);
				float num2 = Random.Range(20f, 46f);
				float cellX = (float)cx * 1f + Mathf.Cos(num) * num2 / 2f;
				float cellY = (float)cy * 1f + Mathf.Sin(num) * num2 / 2f;
				SpawnFx(cellX, cellY, (0f - Mathf.Cos(num)) * num2 * 2.2f, (0f - Mathf.Sin(num)) * num2 * 2.2f, 0.45f, 3f, new Color(0.7f, 0.5f, 1f, 0.85f), gravity: false);
			}
			SpawnFx(cx, cy, 0f, 0f, 0.2f, 26f, new Color(0.55f, 0.35f, 0.9f, 0.8f), gravity: false);
		}

		private void FxBolt(int cx, int cy)
		{
			//IL_002d: 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)
			SpawnFx(cx, cy, 0f, 0f, 0.15f, 22f, new Color(0.85f, 0.9f, 1f, 0.95f), gravity: false);
			for (int i = 0; i < 6; i++)
			{
				SpawnFx(cx, cy, Random.Range(-90f, 90f), Random.Range(30f, 120f), Random.Range(0.25f, 0.45f), 2f, new Color(0.75f, 0.85f, 1f, 0.9f), gravity: true);
			}
		}

		private void ClearFx()
		{
			foreach (Fx item in fxLive)
			{
				((Component)item.image).gameObject.SetActive(false);
			}
			fxLive.Clear();
		}

		private void BuildSidePanel()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_003f: 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_0069: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00f7: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: 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_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Expected O, but got Unknown
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Expected O, but got Unknown
			//IL_070b: Unknown result type (might be due to invalid IL or missing references)
			//IL_073b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0757: Unknown result type (might be due to invalid IL or missing references)
			//IL_077c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0807: Unknown result type (might be due to invalid IL or missing references)
			//IL_0821: Unknown result type (might be due to invalid IL or missing references)
			//IL_0844: Unknown result type (might be due to invalid IL or missing references)
			//IL_085f: Unknown result type (might be due to invalid IL or missing references)
			//IL_088b: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0919: Unknown result type (might be due to invalid IL or missing references)
			//IL_0934: Unknown result type (might be due to invalid IL or missing references)
			//IL_094f: Unknown result type (might be due to invalid IL or missing references)
			//IL_096a: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a17: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a32: Unknown result type (might be due to invalid IL or missing references)
			float height = ctx.height;
			GameObject val = new GameObject("wormsAim");
			val.transform.SetParent((Transform)(object)ctx.panel, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.pivot = new Vector2(0f, 0.5f);
			obj.anchorMin = new Vector2(0f, 0.5f);
			obj.anchorMax = new Vector2(0f, 0.5f);
			obj.sizeDelta = new Vector2(170f, height);
			obj.anchoredPosition = Vector2.zero;
			UiKit.Stretch(((Graphic)UiKit.CreatePanel("back", val.transform, new Color(0.055f, 0.06f, 0.085f, 1f))).rectTransform);
			turnLabel = UiKit.CreateLabel("turn", val.transform, 13f, UiKit.TextPale, (TextAnchor)4);
			turnLabel.Rect.sizeDelta = new Vector2(160f, 18f);
			turnLabel.Rect.anchoredPosition = new Vector2(0f, height * 0.5f - 12f);
			turnLabel.Bold();
			Image val2 = UiKit.CreateImage("dial", val.transform, new Color(0.75f, 0.78f, 0.85f, 0.9f));
			val2.sprite = DialSprite();
			((Graphic)val2).raycastTarget = true;
			dialRect = ((Graphic)val2).rectTransform;
			dialRect.sizeDelta = new Vector2(128f, 64f);
			dialRect.pivot = new Vector2(0.5f, 0f);
			dialRect.anchoredPosition = new Vector2(0f, -4f);
			Image val3 = (needleImg = UiKit.CreateImage("needle", val.transform, UiKit.Gold));
			((Graphic)needleImg).raycastTarget = false;
			needle = ((Graphic)val3).rectTransform;
			needle.pivot = new Vector2(0.5f, 0f);
			needle.sizeDelta = new Vector2(3f, 52f);
			needle.anchoredPosition = new Vector2(0f, -4f);
			powerBar = new UiMeter("powerBg", val.transform, new Vector2(152f, 12f), new Color(0.14f, 0.14f, 0.17f, 1f), UiKit.Green, 2f);
			powerBar.Rect.anchoredPosition = new Vector2(0f, (0f - height) * 0.5f + 52f);
			shootFace = UiKit.CreatePanel("shoot", val.transform, Color.white);
			((Graphic)shootFace).color = UiKit.PanelMid;
			shootRect = ((Graphic)shootFace).rectTransform;
			shootRect.sizeDelta = new Vector2(152f, 32f);
			shootRect.anchoredPosition = new Vector2(0f, (0f - height) * 0.5f + 26f);
			UiKit.Stretch(((Graphic)UiKit.CreateOutline("edge", ((Component)shootFace).transform, UiKit.OutlineBright)).rectTransform);
			shootLabel = UiKit.CreateLabel("label", ((Component)shootFace).transform, 15f, UiKit.TextPale, (TextAnchor)4);
			UiKit.Stretch(shootLabel.Rect);
			shootLabel.Bold();
			shootLabel.Text = "SHOOT";
			GameObject val4 = new GameObject("wormsArsenal");
			val4.transform.SetParent((Transform)(object)ctx.panel, false);
			RectTransform obj2 = val4.AddComponent<RectTransform>();
			obj2.pivot = new Vector2(1f, 0.5f);
			obj2.anchorMin = new Vector2(1f, 0.5f);
			obj2.anchorMax = new Vector2(1f, 0.5f);
			obj2.sizeDelta = new Vector2(140f, height);
			obj2.anchoredPosition = Vector2.zero;
			UiKit.Stretch(((Graphic)UiKit.CreatePanel("back", val4.transform, new Color(0.055f, 0.06f, 0.085f, 1f))).rectTransform);
			WeaponIcons.EnsureLoading();
			weaponBtns = new UiKit.Btn[WeaponNames.Length];
			weaponIcons = (Image[])(object)new Image[WeaponNames.Length];
			nameLabels = new UiKit.Label[WeaponNames.Length];
			ammoLabels = new UiKit.Label[WeaponNames.Length];
			for (int i = 0; i < WeaponNames.Length; i++)
			{
				int captured = i;
				weaponBtns[i] = UiKit.CreateButton($"weapon{i}", val4.transform, new Vector2(62f, 28f), 9f, "", (UnityAction)delegate
				{
					SelectWeapon((Weapon)captured);
				});
				weaponBtns[i].Rect.anchoredPosition = new Vector2(((i % 2 == 0) ? (-1f) : 1f) * 32f, height * 0.5f - 20f - (float)(i / 2) * 30f);
				Image val5 = UiKit.CreateImage($"icon{i}", weaponBtns[i].Go.transform, Color.white);
				((Graphic)val5).raycastTarget = false;
				((Graphic)val5).rectTransform.sizeDelta = new Vector2(18f, 18f);
				((Graphic)val5).rectTransform.anchoredPosition = new Vector2(-20f, 0f);
				((Behaviour)val5).enabled = false;
				weaponIcons[i] = val5;
				UiKit.Label label = UiKit.CreateLabel($"name{i}", weaponBtns[i].Go.transform, 8f, UiKit.TextPale, (TextAnchor)3);
				label.Rect.sizeDelta = new Vector2(44f, 24f);
				label.Rect.anchoredPosition = new Vector2(11f, 1f);
				label.Text = WeaponNames[i];
				nameLabels[i] = label;
				UiKit.Label label2 = UiKit.CreateLabel($"ammo{i}", weaponBtns[i].Go.transform, 9f, UiKit.Gold, (TextAnchor)8);
				label2.Rect.sizeDelta = new Vector2(58f, 12f);
				label2.Rect.anchoredPosition = new Vector2(0f, -8f);
				label2.Bold();
				ammoLabels[i] = label2;
			}
			selectFrame = UiKit.CreateOutline("weaponSel", val4.transform, UiKit.Gold);
			((Graphic)selectFrame).raycastTarget = false;
			((Graphic)selectFrame).rectTransform.sizeDelta = new Vector2(64f, 30f);
			windLabel = UiKit.CreateLabel("windLabel", val4.transform, 11f, UiKit.TextDim, (TextAnchor)4);
			windLabel.Rect.sizeDelta = new Vector2(130f, 14f);
			windLabel.Rect.anchoredPosition = new Vector2(0f, (0f - height) * 0.5f + 18f);
			windLabel.Text = "WIND";
			Image val6 = (windArrowImg = UiKit.CreateImage("windArrow", val4.transform, UiKit.AccentOrange));
			((Graphic)windArrowImg).raycastTarget = false;
			windArrow = ((Graphic)val6).rectTransform;
			windArrow.pivot = new Vector2(0f, 0.5f);
			windArrow.sizeDelta = new Vector2(40f, 5f);
			windArrow.anchoredPosition = new Vector2(0f, (0f - height) * 0.5f + 7f);
			message = UiKit.CreateLabel("msg", (Transform)(object)fieldRect, 15f, UiKit.Gold, (TextAnchor)4);
			message.Rect.sizeDelta = new Vector2(fieldW - 20f, 22f);
			message.Rect.anchoredPosition = new Vector2(0f, fieldH * 0.5f - 14f);
			for (int num = 0; num < 10; num++)
			{
				Image val7 = UiKit.CreateImage($"dot{num}", (Transform)(object)fieldRect, new Color(1f, 1f, 1f, 0.7f));
				((Graphic)val7).raycastTarget = false;
				((Graphic)val7).rectTransform.pivot = new Vector2(0.5f, 0.5f);
				((Graphic)val7).rectTransform.anchorMin = new Vector2(0f, 0.5f);
				((Graphic)val7).rectTransform.anchorMax = new Vector2(0f, 0.5f);
				((Graphic)val7).rectTransform.sizeDelta = new Vector2(3f, 3f);
				((Component)val7).gameObject.SetActive(false);
				dotPool.Add(val7);
			}
			for (int num2 = 0; num2 < 6; num2++)
			{
				Image val8 = UiKit.CreateImage($"shell{num2}", (Transform)(object)fieldRect, Color.white);
				((Graphic)val8).raycastTarget = false;
				((Graphic)val8).rectTransform.pivot = new Vector2(0.5f, 0.5f);
				((Graphic)val8).rectTransform.anchorMin = new Vector2(0f, 0.5f);
				((Graphic)val8).rectTransform.anchorMax = new Vector2(0f, 0.5f);
				((Graphic)val8).rectTransform.sizeDelta = new Vector2(4f, 4f);
				((Component)val8).gameObject.SetActive(false);
				shellPool.Add(val8);
			}
		}

		private static int AmmoOf(Unit u, Weapon wp)
		{
			return u.ammo[(int)wp];
		}

		private static bool Targeted(Weapon wp)
		{
			if (wp != Weapon.Meteors && wp != Weapon.Thunderbolt)
			{
				return wp == Weapon.Bunker;
			}
			return true;
		}

		private bool LocalOwns(Unit u)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (match == null)
			{
				return true;
			}
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					if (((NetworkInstanceId)(ref netId)).Value == u.ownerNetId)
					{
						return true;
					}
				}
			}
			return false;
		}

		private string OwnerName(Unit u)
		{
			//IL_001e: 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)
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					if (((NetworkInstanceId)(ref netId)).Value == u.ownerNetId && !string.IsNullOrEmpty(readOnlyInstances.userName))
					{
						return readOnlyInstances.userName;
					}
				}
			}
			return CommandoSprites.ColorwayNames[u.colorway];
		}

		internal void QueueCanonShot(WormsShot shot)
		{
			canonQueue.Enqueue(shot);
		}

		internal void ApplyShot(WormsShot shot, bool animate)
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (phase == Phase.Won)
			{
				appliedShots.Add(shot);
				awaitingEcho = false;
				return;
			}
			int num = -1;
			for (int i = 0; i < units.Count; i++)
			{
				if (units[i].ownerNetId == shot.shooterNetId)
				{
					num = i;
					break;
				}
			}
			if (num < 0)
			{
				appliedShots.Add(shot);
				return;
			}
			if (num != turnUnit)
			{
				turnUnit = num;
				RefreshPanel();
			}
			Unit unit = units[turnUnit];
			appliedShots.Add(shot);
			awaitingEcho = false;
			if (dugBankMatchId != match.matchId)
			{
				dugBankMatchId = match.matchId;
				dugBankedShots = 0;
			}
			dugCreditArmed = appliedShots.Count > dugBankedShots;
			if (dugCreditArmed)
			{
				dugBankedShots = appliedShots.Count;
			}
			if (shot.weapon == byte.MaxValue)
			{
				NextTurn();
			}
			else if (shot.weapon == 254)
			{
				unit.alive = false;
				unit.hp = 0;
				((Graphic)unit.image).color = new Color(0.25f, 0.25f, 0.25f, 0.4f);
				PlaceUnitVisual(unit);
				message.Text = OwnerName(unit) + " left the match";
				if (!CheckMatchWon())
				{
					NextTurn();
				}
			}
			else if (ValidWeaponByte(shot.weapon))
			{
				if (Targeted((Weapon)shot.weapon))
				{
					weapon = (Weapon)shot.weapon;
					targetX = Mathf.Clamp((int)shot.tx, 0, W - 1);
					targetY = Mathf.Clamp((int)shot.ty, 0, H - 1);
					unit.facingRight = targetX >= unit.xQ / 65536;
					SpendAmmo(unit, weapon);
					if (weapon == Weapon.Meteors)
					{
						ExecuteMeteors();
						if (!animate)
						{
							FastResolve();
						}
					}
					else if (weapon == Weapon.Thunderbolt)
					{
						ExecuteBolt();
					}
					else
					{
						BuildBunker(targetX, targetY);
						NextTurn();
					}
				}
				else
				{
					weapon = (Weapon)shot.weapon;
					unit.aimAngleDeg = Mathf.Clamp((int)shot.angle, 0, 180);
					unit.aimPower = Mathf.Clamp((int)shot.power, 5, 100);
					unit.facingRight = unit.aimAngleDeg <= 90;
					SpendAmmo(unit, weapon);
					ExecuteBallistic(unit);
					if (!animate)
					{
						FastResolve();
					}
				}
			}
			LogStateHash();
		}

		internal void CatchUp(WormsShot[] shots)
		{
			for (int i = KnownShotCount; i < shots.Length; i++)
			{
				canonQueue.Enqueue(shots[i]);
			}
		}

		private void FastResolve()
		{
			int num = 0;
			while (phase == Phase.Flight && num++ < 20000)
			{
				StepShells();
			}
			surface.Flush();
		}

		private bool CheckMatchWon()
		{
			int num = 0;
			Unit unit = null;
			foreach (Unit unit2 in units)
			{
				if (unit2.alive)
				{
					num++;
					unit = unit2;
				}
			}
			if (num > 1)
			{
				return false;
			}
			phase = Phase.Won;
			message.Text = ((unit == null) ? "MUTUAL DESTRUCTION" : ((match != null) ? (OwnerName(unit) + " WINS!") : (CommandoSprites.ColorwayNames[unit.colorway] + " WINS — click to rematch")));
			return true;
		}

		private void SubmitShot(WormsShot shot)
		{
			if (NetworkServer.active)
			{
				ArcadeHost.HostApplyWormsShot(shot);
				return;
			}
			awaitingEcho = true;
			awaitingEchoSince = Time.unscaledTime;
			NetMessageExtensions.Send((INetMessage)(object)new WormsShotRequestMessage(match.matchId, shot), (NetworkDestination)2);
		}

		private void LogStateHash()
		{
			if (match == null || !ModOptions.VerboseLogging.Value)
			{
				return;
			}
			uint h = 2166136261u;
			foreach (Unit unit in units)
			{
				Mix((uint)unit.xQ);
				Mix((uint)unit.yQ);
				Mix((uint)unit.hp);
				Mix(unit.alive ? 1u : 0u);
				Mix(unit.facingRight ? 1u : 0u);
				int[] ammo = unit.ammo;
				for (int i = 0; i < ammo.Length; i++)
				{
					Mix((uint)(ammo[i] + 8));
				}
			}
			Mix((uint)fires.Count);
			Mix((uint)(windLevel + 512));
			Mix(rngState);
			uint num = 0u;
			for (int j = 0; j < solid.Length; j++)
			{
				num = ((num << 1) | (num >> 31)) ^ solid[j];
			}
			Mix(num);
			ScorchedVoxelsPlugin.Log.LogInfo((object)$"[SV-ARCADE] match {match.matchId} shot {appliedShots.Count} hash {h:X8}");
			void Mix(uint v)
			{
				h ^= v;
				h *= 16777619u;
			}
		}

		private static Sprite DialSprite()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)dialSprite != (Object)null)
			{
				return dialSprite;
			}
			Texture2D val = new Texture2D(128, 64, (TextureFormat)5, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[8192];
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 128; j++)
				{
					int num = 0;
					for (int k = 0; k < 3; k++)
					{
						for (int l = 0; l < 3; l++)
						{
							if (Inside((float)j + ((float)l + 0.5f) / 3f, (float)i + ((float)k + 0.5f) / 3f))
							{
								num++;
							}
						}
					}
					array[i * 128 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)(num * 255 / 9));
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			dialSprite = Sprite.Create(val, new Rect(0f, 0f, 128f, 64f), new Vector2(0.5f, 0f), 100f);
			return dialSprite;
			static bool Inside(float x, float y)
			{
				float num2 = x - 64f;
				float num3 = y - 2f;
				if (num3 < 0f)
				{
					return false;
				}
				float num4 = num2 * num2 + num3 * num3;
				if (num4 > 3364f)
				{
					return false;
				}
				if (num4 >= 2500f)
				{
					return true;
				}
				float num5 = Mathf.Atan2(num3, num2) * 57.29578f;
				float[] array2 = new float[7] { 0f, 30f, 60f, 90f, 120f, 150f, 180f };
				foreach (float num6 in array2)
				{
					if (Mathf.Abs(num5 - num6) < 2.2f && num4 > 1764f)
					{
						return true;
					}
				}
				return false;
			}
		}

		private void SelectWeapon(Weapon wp)
		{
			if (phase != Phase.Aiming)
			{
				return;
			}
			Unit unit = units[turnUnit];
			if (AmmoOf(unit, wp) != 0)
			{
				if (wp != weapon)
				{
					charging = false;
				}
				weapon = wp;
				if (Targeted(wp))
				{
					targetX = Mathf.Clamp(unit.xQ / 65536 + (unit.facingRight ? 24 : (-24)), 4, W - 5);
					targetY = Mathf.Clamp(unit.yQ / 65536 + 4, 4, H - 5);
				}
				HideDots();
				RefreshPanel();
			}
		}

		private void RefreshPanel()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			Unit unit = units[turnUnit];
			turnLabelBase = ((match != null) ? (OwnerName(unit) + "'s turn") : (CommandoSprites.ColorwayNames[unit.colorway] + "'s turn"));
			turnLabel.Text = turnLabelBase;
			shownAutoPass = -1;
			turnLabel.Color = CommandoSprites.Tint(unit.colorway);
			bool flag = LocalOwns(unit);
			for (int i = 0; i < weaponBtns.Length; i++)
			{
				int num = AmmoOf(unit, (Weapon)i);
				bool flag2 = flag && num != 0;
				Sprite val = WeaponIcons.Get(i);
				weaponIcons[i].sprite = val;
				((Behaviour)weaponIcons[i]).enabled = (Object)(object)val != (Object)null;
				((Graphic)weaponIcons[i]).color = (Color)(flag2 ? Color.white : new Color(1f, 1f, 1f, 0.3f));
				nameLabels[i].Text = (((Object)(object)val != (Object)null) ? WeaponNames[i] : (ShortNames[i] + "?"));
				nameLabels[i].Color = (flag2 ? UiKit.TextPale : UiKit.TextDim);
				ammoLabels[i].Text = ((num < 0) ? "" : $"x{num}");
				weaponBtns[i].Interactable = flag2;
			}
			((Graphic)selectFrame).rectTransform.anchoredPosition = weaponBtns[(int)weapon].Rect.anchoredPosition;
			windLabel.Text = ((windLevel == 0) ? "WIND  —" : $"WIND  {Mathf.Abs(windLevel)}");
			float num2 = 6f + (float)Mathf.Abs(windLevel) * 6f;
			windArrow.sizeDelta = new Vector2(num2, 5f);
			((Transform)windArrow).localScale = new Vector3((windLevel >= 0) ? 1f : (-1f), 1f, 1f);
			((Graphic)windArrowImg).color = ((windLevel == 0) ? UiKit.TextDim : UiKit.AccentOrange);
		}

		private void TickAutoPassHud()
		{
			float num = 45f - (Time.unscaledTime - turnStartedAt);
			int num2 = ((num <= 10f) ? Mathf.Max(0, Mathf.CeilToInt(num)) : (-1));
			if (num2 != shownAutoPass)
			{
				shownAutoPass = num2;
				turnLabel.Text = ((num2 < 0) ? turnLabelBase : $"{turnLabelBase} — auto-pass in {num2}s");
			}
		}

		private void BeginTurn(int idx)
		{
			turnUnit = idx;
			if (AmmoOf(units[turnUnit], weapon) == 0)
			{
				weapon = Weapon.Bazooka;
			}
			charging = false;
			turnStartedAt = Time.unscaledTime;
			phase = Phase.Aiming;
			MaybeSpawnCrate();
			RefreshPanel();
		}

		private void MaybeSpawnCrate()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			bool num = RngRange(0, 100) < 25;
			int num2 = RngRange(8, W - 8);
			Weapon weapon = CrateLootPool[RngRange(0, CrateLootPool.Length)];
			if (!num || (Object)(object)crateGo != (Object)null)
			{
				return;
			}
			foreach (Unit unit in units)
			{
				if (unit.alive && Mathf.Abs(unit.xQ / 65536 - num2) < 14)
				{
					return;
				}
			}
			crateX = num2;
			crateY = SurfaceYAt(num2);
			crateLoot = weapon;
			crateGo = new GameObject("crate");
			crateGo.transform.SetParent((Transform)(object)fieldRect, false);
			RectTransform val = (crateRect = crateGo.AddComponent<RectTransform>());
			val.pivot = new Vector2(0.5f, 0f);
			val.anchorMin = new Vector2(0f, 0.5f);
			val.anchorMax = new Vector2(0f, 0.5f);
			val.sizeDelta = new Vector2(14f, 12f);
			val.anchoredPosition = new Vector2((float)crateX * 2f, (float)crateY * 2f - fieldH * 0.5f);
			Image obj = UiKit.CreateImage("box", crateGo.transform, new Color(0.45f, 0.34f, 0.16f, 1f));
			UiKit.Stretch(((Graphic)obj).rectTransform);
			((Graphic)obj).raycastTarget = false;
			UiKit.Stretch(((Graphic)UiKit.CreateOutline("lid", crateGo.transform, UiKit.Gold)).rectTransform);
			UiKit.Label label = UiKit.CreateLabel("q", crateGo.transform, 10f, UiKit.Gold, (TextAnchor)4);
			UiKit.Stretch(label.Rect);
			label.Bold();
			label.Text = "?";
		}

		private void DestroyCrateVisual()
		{
			if ((Object)(object)crateGo != (Object)null)
			{
				Object.Destroy((Object)(object)crateGo);
			}
			crateGo = null;
			crateRect = null;
			crateX = -1;
		}

		private void SettleCrate()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)crateGo == (Object)null))
			{
				int num = SurfaceYAt(crateX);
				if (num != crateY)
				{
					crateY = num;
					crateRect.anchoredPosition = new Vector2((float)crateX * 2f, (float)crateY * 2f - fieldH * 0.5f);
				}
			}
		}

		private void TryOpenCrate(int cx, int cy, int dmgR)
		{
			if (!((Object)(object)crateGo == (Object)null))
			{
				int num = crateX - cx;
				int num2 = crateY + 2 - cy;
				if (num * num + num2 * num2 <= dmgR * dmgR)
				{
					Unit unit = units[turnUnit];
					unit.ammo[(int)crateLoot]++;
					message.Text = CommandoSprites.ColorwayNames[unit.colorway] + " looted a " + WeaponNames[(int)crateLoot] + "!";
					DestroyCrateVisual();
				}
			}
		}

		private void NextTurn()
		{
			windLevel = NextWind();
			for (int i = 1; i <= units.Count; i++)
			{
				int num = (turnUnit + i) % units.Count;
				if (units[num].alive)
				{
					BeginTurn(num);
					return;
				}
			}
			phase = Phase.Won;
		}

		public void Tick(float dt)
		{
			while (phase != Phase.Flight && canonQueue.Count > 0)
			{
				WormsShot shot = canonQueue.Dequeue();
				ApplyShot(shot, canonQueue.Count == 0);
			}
			switch (phase)
			{
			case Phase.Aiming:
				TickAiming(dt);
				if (match != null)
				{
					TickAutoPassHud();
				}
				break;
			case Phase.Flight:
				tickCarry += dt;
				while (tickCarry >= 1f / 60f)
				{
					tickCarry -= 1f / 60f;
					if (StepShells())
					{
						break;
					}
				}
				foreach (Shell shell in shells)
				{
					PlaceShellVisual(shell);
				}
				break;
			case Phase.Won:
				if (match == null && ArcadeInput.ActionDown)
				{
					RestartMatch();
				}
				break;
			}
			if (iconsSeen != WeaponIcons.Version)
			{
				iconsSeen = WeaponIcons.Version;
				RefreshPanel();
			}
			if (boltRepaintAt > 0f && Time.unscaledTime >= boltRepaintAt)
			{
				boltRepaintAt = 0f;
				foreach (int boltCell in boltCells)
				{
					RepaintCell(boltCell % W, boltCell / W);
				}
				boltCells.Clear();
			}
			TickFx(dt);
			surface.Flush();
		}

		private void TickAiming(float aimDt)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			if (ArcadeInput.Blocked)
			{
				charging = false;
				return;
			}
			Unit unit = units[turnUnit];
			if (!LocalOwns(unit))
			{
				charging = false;
				HideDots();
				UpdateAimVisuals(unit);
				shootLabel.Text = "WAITING";
				return;
			}
			if (awaitingEcho)
			{
				if (Time.unscaledTime - awaitingEchoSince > 4f)
				{
					awaitingEcho = false;
				}
				charging = false;
				shootLabel.Text = "...";
				return;
			}
			for (int i = 0; i < 9; i++)
			{
				if (Input.GetKeyDown((KeyCode)(49 + i)))
				{
					SelectWeapon((Weapon)i);
				}
			}
			if (Targeted(weapon))
			{
				TickTargetedAim(unit);
				return;
			}
			if (Input.GetMouseButton(0) && RectTransformUtility.RectangleContainsScreenPoint(dialRect, Vector2.op_Implicit(Input.mousePosition)))
			{
				Vector2 val = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(dialRect, Vector2.op_Implicit(Input.mousePosition), (Camera)null, ref val);
				if (((Vector2)(ref val)).sqrMagnitude > 16f)
				{
					unit.aimAngleDeg = Mathf.Clamp(Mathf.RoundToInt(Mathf.Atan2(val.y, val.x) * 57.29578f), 0, 180);
				}
			}
			if (Input.GetKey((KeyCode)97) || Input.GetKey((KeyCode)276))
			{
				unit.aimAngleDeg = Mathf.Min(180, unit.aimAngleDeg + 1);
			}
			if (Input.GetKey((KeyCode)100) || Input.GetKey((KeyCode)275))
			{
				unit.aimAngleDeg = Mathf.Max(0, unit.aimAngleDeg - 1);
			}
			bool flag = (Input.GetMouseButton(0) && RectTransformUtility.RectangleContainsScreenPoint(shootRect, Vector2.op_Implicit(Input.mousePosition))) || Input.GetKey((KeyCode)32);
			if (flag && !charging)
			{
				charging = true;
				chargeT = 0f;
			}
			if (charging)
			{
				chargeT += aimDt * 1.15f;
				unit.aimPower = 10 + Mathf.RoundToInt(90f * Mathf.PingPong(chargeT, 1f));
				if (!flag)
				{
					charging = false;
					Fire(unit);
					return;
				}
			}
			unit.facingRight = unit.aimAngleDeg <= 90;
			UpdateAimVisuals(unit);
			PlaceUnitVisual(unit);
			DrawTrajectoryStub(unit);
		}

		private void UpdateAimVisuals(Unit u)
		{
			//IL_001d: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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)
			((Transform)needle).localRotation = Quaternion.Euler(0f, 0f, (float)u.aimAngleDeg - 90f);
			((Graphic)needleImg).color = CommandoSprites.Tint(u.colorway);
			float num = (float)u.aimPower / 100f;
			powerBar.SetFrac(num);
			((Graphic)powerBar.Fill).color = (Color)((num < 0.5f) ? UiKit.Green : ((num < 0.8f) ? UiKit.Gold : new Color(0.9f, 0.35f, 0.2f)));
			((Graphic)shootFace).color = (Color)(charging ? new Color(0.28f, 0.16f, 0.1f, 1f) : UiKit.PanelMid);
			shootLabel.Text = (charging ? "RELEASE!" : "SHOOT");
		}

		private void TickTargetedAim(Unit u)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKey((KeyCode)276) || Input.GetKey((KeyCode)97))
			{
				targetX = Mathf.Max(4, targetX - 1);
			}
			if (Input.GetKey((KeyCode)275) || Input.GetKey((KeyCode)100))
			{
				targetX = Mathf.Min(W - 5, targetX + 1);
			}
			if (Input.GetKey((KeyCode)273) || Input.GetKey((KeyCode)119))
			{
				targetY = Mathf.Min(H - 5, targetY + 1);
			}
			if (Input.GetKey((KeyCode)274) || Input.GetKey((KeyCode)115))
			{
				targetY = Mathf.Max(4, targetY - 1);
			}
			bool flag = RectTransformUtility.RectangleContainsScreenPoint(fieldRect, Vector2.op_Implicit(Input.mousePosition));
			if (flag)
			{
				Vector2 val = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(fieldRect, Vector2.op_Implicit(Input.mousePosition), (Camera)null, ref val);
				targetX = Mathf.Clamp(Mathf.RoundToInt(val.x / 2f), 4, W - 5);
				targetY = Mathf.Clamp(Mathf.RoundToInt((val.y + fieldH * 0.5f) / 2f), 4, H - 5);
			}
			int i = 0;
			if (weapon == Weapon.Meteors || weapon == Weapon.Thunderbolt)
			{
				float num = (float)windLevel * ((float)(20 * Wind16[(int)weapon]) / 16f) / 546f;
				int num2 = H + 6;
				for (int j = 0; j < 7; j++)
				{
					if (i >= dotPool.Count)
					{
						break;
					}
					int num3 = H - 2 - j * (H - 4 - targetY) / 7;
					PlaceDot(ref i, targetX + Mathf.RoundToInt((float)(num2 - num3) * num), num3);
				}
				int num4 = Mathf.RoundToInt((float)(num2 - targetY) * num);
				PlaceDot(ref i, targetX + num4 - 2, targetY);
				PlaceDot(ref i, targetX + num4 + 2, targetY);
			}
			else
			{
				for (int k = 0; k < 4; k++)
				{
					if (i >= dotPool.Count)
					{
						break;
					}
					PlaceDot(ref i, targetX, targetY + k * 13 / 3);
				}
				for (int l = 1; l <= 3; l++)
				{
					if (i >= dotPool.Count)
					{
						break;
					}
					PlaceDot(ref i, targetX + l * 6 / 3, targetY);
					PlaceDot(ref i, targetX + l * 6 / 3, targetY + 14 - 1);
				}
			}
			for (; i < dotPool.Count; i++)
			{
				((Component)dotPool[i]).gameObject.SetActive(false);
			}
			u.facingRight = targetX >= u.xQ / 65536;
			PlaceUnitVisual(u);
			bool flag2 = Input.GetMouseButtonDown(0) && RectTransformUtility.RectangleContainsScreenPoint(shootRect, Vector2.op_Implicit(Input.mousePosition));
			if ((Input.GetMouseButtonDown(0) && flag) || flag2 || Input.GetKeyDown((KeyCode)32))
			{
				FireTargeted(u);
			}
		}

		private void PlaceDot(ref int dot, int cx, int cy)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Image obj = dotPool[dot++];
			((Component)obj).gameObject.SetActive(true);
			((Graphic)obj).color = new Color(1f, 1f, 1f, 0.75f);
			((Graphic)obj).rectTransform.anchoredPosition = new Vector2((float)cx * 2f, (float)cy * 2f - fieldH * 0.5f);
		}

		private (int vxQ, int vyQ) LaunchVelocity(Unit u)
		{
			int num = 144000 * u.aimPower / 100;
			int item = (int)((long)CosDegQ16(u.aimAngleDeg) * (long)num / 65536);
			int item2 = (int)((long)SinDegQ16(u.aimAngleDeg) * (long)num / 65536);
			return (vxQ: item, vyQ: item2);
		}

		private void DrawTrajectoryStub(Unit u)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			(int vxQ, int vyQ) tuple = LaunchVelocity(u);
			int num = tuple.vxQ;
			int num2 = tuple.vyQ;
			int num3 = u.xQ;
			int num4 = u.yQ + 327680;
			int num5 = windLevel * 20 * Wind16[(int)weapon] / 16;
			int i = 0;
			for (int j = 0; j < 30; j++)
			{
				if (i >= dotPool.Count)
				{
					break;
				}
				num += num5;
				num2 -= 546;
				num3 += num;
				num4 += num2;
				if (Solid(num3 / 65536, num4 / 65536))
				{
					break;
				}
				if (j % 3 == 2)
				{
					Image obj = dotPool[i++];
					((Component)obj).gameObject.SetActive(true);
					((Graphic)obj).rectTransform.anchoredPosition = new Vector2((float)num3 / 65536f * 2f, (float)num4 / 65536f * 2f - fieldH * 0.5f);
					((Graphic)obj).color = new Color(1f, 1f, 1f, 0.75f - (float)j * 0.02f);
				}
			}
			for (; i < dotPool.Count; i++)
			{
				((Component)dotPool[i]).gameObject.SetActive(false);
			}
		}

		private void HideDots()
		{
			foreach (Image item in dotPool)
			{
				((Component)item).gameObject.SetActive(false);
			}
		}

		private void Fire(Unit u)
		{
			if (AmmoOf(u, weapon) != 0)
			{
				if (match != null)
				{
					SubmitShot(new WormsShot
					{
						shooterNetId = u.ownerNetId,
						weapon = (byte)weapon,
						angle = (byte)Mathf.Clamp(u.aimAngleDeg, 0, 180),
						power = (byte)Mathf.Clamp(u.aimPower, 5, 100)
					});
				}
				else
				{
					SpendAmmo(u, weapon);
					ExecuteBallistic(u);
				}
			}
		}

		private void ExecuteBallistic(Unit u)
		{
			HideDots();
			message.Text = "";
			var (vxQ, vyQ) = LaunchVelocity(u);
			shells.Clear();
			SpawnShell(u.xQ, u.yQ + 327680, vxQ, vyQ, weapon, bomblet: false, turnUnit);
			phase = Phase.Flight;
			tickCarry = 0f;
		}

		private void FireTargeted(Unit u)
		{
			if (AmmoOf(u, weapon) == 0)
			{
				return;
			}
			if (match != null)
			{
				SubmitShot(new WormsShot
				{
					shooterNetId = u.ownerNetId,
					weapon = (byte)weapon,
					tx = (ushort)Mathf.Clamp(targetX, 0, W - 1),
					ty = (ushort)Mathf.Clamp(targetY, 0, H - 1)
				});
				return;
			}
			SpendAmmo(u, weapon);
			if (weapon == Weapon.Meteors)
			{
				ExecuteMeteors();
				return;
			}
			if (weapon == Weapon.Thunderbolt)
			{
				ExecuteBolt();
				return;
			}
			BuildBunker(targetX, targetY);
			NextTurn();
		}

		private static void SpendAmmo(Unit u, Weapon wp)
		{
			if (u.ammo[(int)wp] > 0)
			{
				u.ammo[(int)wp]--;
			}
		}

		private void ExecuteMeteors()
		{
			HideDots();
			message.Text = "";
			shells.Clear();
			for (int i = 0; i < 3; i++)
			{
				int num = Mathf.Clamp(targetX + (i - 1) * 7, 1, W - 2);
				SpawnShell(num * 65536, (H + 6 + i * 3) * 65536, 0, 0, Weapon.Meteors, bomblet: false);
			}
			phase = Phase.Flight;
			tickCarry = 0f;
		}

		private void ExecuteBolt()
		{
			//IL_0099: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			HideDots();
			message.Text = "";
			int num = 1;
			int num2 = -1;
			for (int num3 = H - 1; num3 >= 1; num3--)
			{
				int num4 = UnitPixelAt(targetX, num3, -1);
				if (num4 >= 0)
				{
					num = num3;
					num2 = num4;
					break;
				}
				if (Solid(targetX, num3))
				{
					num = num3;
					break;
				}
			}
			boltCells.Clear();
			for (int i = num; i < H; i++)
			{
				surface.Set(targetX, i, new Color32((byte)240, (byte)244, byte.MaxValue, byte.MaxValue));
				if ((i & 1) == 0)
				{
					surface.Set(targetX - 1, i, new Color32((byte)150, (byte)180, (byte)250, byte.MaxValue));
					surface.Set(targetX + 1, i, new Color32((byte)150, (byte)180, (byte)250, byte.MaxValue));
				}
				boltCells.Add(i * W + targetX);
				if (targetX > 0)
				{
					boltCells.Add(i * W + targetX - 1);
				}
				if (targetX < W - 1)
				{
					boltCells.Add(i * W + targetX + 1);
				}
			}
			boltRepaintAt = Time.unscaledTime + 0.35f;
			FxBolt(targetX, num);
			int num5 = 0;
			for (int j = 0; j < 14; j += 2)
			{
				num5 += CarveCircle(targetX, num - j, 2, j == 0);
			}
			CreditDug(num5);
			int num6 = 5;
			for (int k = 0; k < units.Count; k++)
			{
				Unit unit = units[k];
				if (unit.alive)
				{
					int num7 = unit.xQ / 65536 - targetX;
					int num8 = unit.yQ / 65536 + 5 - num;
					int num9 = Mathf.RoundToInt(Mathf.Sqrt((float)(num7 * num7 + num8 * num8)));
					if (k == num2)
					{
						num9 = 0;
					}
					if (num9 < DmgR[num6])
					{
						Hurt(unit, Dmg[num6] * (DmgR[num6] - num9) / DmgR[num6]);
					}
				}
			}
			TryOpenCrate(targetX, num, DmgR[num6]);
			SettleUnits();
			if (!CheckMatchWon())
			{
				NextTurn();
			}
		}

		private void CreditDug(int dug)
		{
			if (dug > 0 && turnUnit < units.Count && LocalOwns(units[turnUnit]) && (match == null || dugCreditArmed))
			{
				UserLifetimeStats.AddWormsDug(profileKey, dug);
			}
		}

		private void Hurt(Unit u, int amount)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			u.hp -= amount;
			if (u.hp <= 0)
			{
				u.hp = 0;
				u.alive = false;
				((Graphic)u.image).color = new Color(0.25f, 0.25f, 0.25f, 0.75f);
			}
			PlaceUnitVisual(u);
		}

		private void BuildBunker(int bx, int by)
		{
			for (int i = 0; i < 14; i++)
			{
				for (int j = 0; j < 2; j++)
				{
					Fill(bx + j, by + i);
				}
			}
			for (int k = 2; k < 6; k++)
			{
				for (int l = 0; l < 2; l++)
				{
					Fill(bx + k, by + l);
					Fill(bx + k, by + 14 - 1 - l);
				}
			}
			SettleCrate();
			void Fill(int x, int y)
			{
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				if (x >= 0 && x < W && y >= 0 && y < H && solid[y * W + x] == 0)
				{
					foreach (Unit unit in units)
					{
						int num = unit.xQ / 65536;
						if (unit.alive && x >= num - 3 && x <= num + 2 && y >= unit.yQ / 65536 && y <= unit.yQ / 65536 + 11)
						{
							return;
						}
					}
					solid[y * W + x] = 3;
					surface.Set(x, y, FreshDirt);
				}
			}
		}

		private void SpawnShell(int xQ, int yQ, int vxQ, int vyQ, Weapon wp, bool bomblet, int ignoreUnit = -1)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			Image val = null;
			foreach (Image item in shellPool)
			{
				if (!((Component)item).gameObject.activeSelf)
				{
					val = item;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				val = shellPool[shellPool.Count - 1];
			}
			((Component)val).gameObject.SetActive(true);
			((Graphic)val).color = (Color)(bomblet ? UiKit.Gold : (wp switch
			{
				Weapon.GravCube => new Color(0.75f, 0.55f, 1f), 
				Weapon.Molotov => new Color(1f, 0.42f, 0.18f), 
				Weapon.Meteors => new Color(1f, 0.55f, 0.25f), 
				_ => Color.white, 
			}));
			shells.Add(new Shell
			{
				xQ = xQ,
				yQ = yQ,
				vxQ = vxQ,
				vyQ = vyQ,
				weapon = wp,
				fuse = ((wp == Weapon.Grenade && !bomblet) ? 180 : (bomblet ? 360 : 0)),
				arm = (bomblet ? 1 : 0),
				bomblet = bomblet,
				ignoreUnit = ignoreUnit,
				image = val
			});
		}

		private int UnitPixelAt(int cx, int cy, int ignore)
		{
			for (int i = 0; i < units.Count; i++)
			{
				if (i != ignore && units[i].alive && UnitOpaqueAt(units[i], cx, cy))
				{
					return i;
				}
			}
			return -1;
		}

		private bool UnitOpaqueAt(Unit u, int cx, int cy)
		{
			int num = u.xQ / 65536;
			int num2 = u.yQ / 65536;
			int num3 = cx - (num - 3);
			int num4 = cy - num2;
			if (num3 < 0 || num3 > 5 || num4 < 0 || num4 > 10)
			{
				return false;
			}
			if (!u.facingRight)
			{
				num3 = 5 - num3;
			}
			return CommandoSprites.CommandoOpaque(0f, num3, num4);
		}

		private bool StepShells()
		{
			int num = windLevel * 20;
			for (int num2 = shells.Count - 1; num2 >= 0; num2--)
			{
				Shell shell = shells[num2];
				if (!shell.drilling)
				{
					shell.vxQ += num * Wind16[(int)shell.weapon] / 16;
					shell.vyQ -= 546;
				}
				int num3 = Mathf.Max(1, Mathf.Max(Mathf.Abs(shell.vxQ), Mathf.Abs(shell.vyQ)) / 65536 + 1);
				bool flag = false;
				for (int i = 0; i < num3; i++)
				{
					if (flag)
					{
						break;
					}
					shell.xQ += shell.vxQ / num3;
					shell.yQ += shell.vyQ / num3;
					int num4 = FloorCell(shell.xQ);
					int num5 = FloorCell(shell.yQ);
					if (shell.ignoreUnit >= 0 && !UnitOpaqueAt(units[shell.ignoreUnit], num4, num5))
					{
						shell.ignoreUnit = -1;
					}
					if (shell.arm > 0 && !Solid(num4, num5) && UnitPixelAt(num4, num5, -1) < 0)
					{
						shell.arm = 0;
					}
					if (shell.drilling && !Solid(num4, num5) && UnitPixelAt(num4, num5, shell.ignoreUnit) < 0)
					{
						if (++shell.drillAir > 12)
						{
							Explode(num2, num4, num5, -1);
							flag = true;
						}
					}
					else if (num4 < -4 || num4 > W + 4 || num5 < -8 || num5 > H + 320)
					{
						RemoveShell(num2);
						flag = true;
					}
					else
					{
						if (shell.arm != 0 || (!Solid(num4, num5) && UnitPixelAt(num4, num5, shell.ignoreUnit) < 0))
						{
							continue;
						}
						int num6 = UnitPixelAt(num4, num5, shell.ignoreUnit);
						if (shell.weapon == Weapon.Drill && !shell.bomblet && num6 < 0)
						{
							if (!shell.drilling)
							{
								shell.drilling = true;
								int num7 = Mathf.Max(Mathf.Abs(shell.vxQ), Mathf.Abs(shell.vyQ));
								if (num7 > 0)
								{
									shell.vxQ = (int)((long)shell.vxQ * 21845L / num7);
									shell.vyQ = (int)((long)shell.vyQ * 21845L / num7);
								}
							}
							CreditDug(CarveCircle(num4, num5, 2, rim: false));
							shell.drilled++;
							shell.drillAir = 0;
							if (shell.drilled > 90)
							{
								Explode(num2, num4, num5, -1);
								flag = true;
							}
						}
						else if (shell.weapon == Weapon.Grenade && !shell.bomblet)
						{
							shell.xQ -= shell.vxQ / num3;
							shell.yQ -= shell.vyQ / num3;
							if (Mathf.Abs(shell.vyQ) >= Mathf.Abs(shell.vxQ))
							{
								shell.vyQ = -shell.vyQ / 2;
							}
							else
							{
								shell.vxQ = -shell.vxQ / 2;
							}
							shell.vxQ = shell.vxQ * 7 / 8;
						}
						else
						{
							Explode(num2, num4, num5, num6);
							flag = true;
						}
					}
				}
				if (!flag && shell.fuse > 0 && --shell.fuse == 0)
				{
					Explode(num2, FloorCell(shell.xQ), FloorCell(shell.yQ), -1);
				}
			}
			StepFires();
			if (shells.Count == 0 && fires.Count == 0)
			{
				SettleUnits();
				if (CheckMatchWon())
				{
					return true;
				}
				NextTurn();
				return true;
			}
			return false;
		}

		private void StepFires()
		{
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			if (fires.Count == 0)
			{
				fireClock = 0;
				return;
			}
			fireClock++;
			bool flag = fireClock % 12 == 0;
			bool flag2 = fireClock % 15 == 0;
			for (int num = fires.Count - 1; num >= 0; num--)
			{
				FireCell value = fires[num];
				value.life--;
				if (flag)
				{
					int y = value.y;
					if (Solid(value.x, value.y - 1))
					{
						CreditDug(CarveCircle(value.x, value.y - 1, 1, rim: false));
						value.y = Mathf.Max(1, value.y - 1);
					}
					else if (value.y > 2 && !Solid(value.x, value.y - 2))
					{
						value.y--;
					}
					if (value.y != y)
					{
						RepaintCell(value.x, y);
						RepaintCell(value.x, y + 1);
					}
				}
				if (flag2)
				{
					int num2 = UnitPixelAt(value.x, value.y, -1);
					if (num2 < 0)
					{
						num2 = UnitPixelAt(value.x, value.y + 1, -1);
					}
					if (num2 >= 0 && units[num2].alive)
					{
						Hurt(units[num2], 1);
					}
				}
				if (value.life <= 0)
				{
					RepaintCell(value.x, value.y);
					RepaintCell(value.x, value.y + 1);
					if (Solid(value.x, value.y - 1))
					{
						surface.Set(value.x, value.y - 1, ScorchCol);
					}
					fires.RemoveAt(num);
				}
				else
				{
					fires[num] = value;
					Color32 c = (Color32)((((value.x + value.y + fireClock / 3) & 1) == 0) ? FireCol : new Color32((byte)252, (byte)210, (byte)80, byte.MaxValue));
					surface.Set(value.x, value.y, c);
					if (((value.x ^ (fireClock / 4)) & 3) == 0)
					{
						surface.Set(value.x, value.y + 1, new Color32((byte)140, (byte)70, (byte)32, byte.MaxValue));
					}
				}
			}
		}

		private void RemoveShell(int i)
		{
			((Component)shells[i].image).gameObject.SetActive(false);
			shells.RemoveAt(i);
		}

		private void Explode(int shellIdx, int cx, int cy, int directUnit)
		{
			Shell shell = shells[shellIdx];
			int num = (int)shell.weapon;
			int r = (shell.bomblet ? CarveR[2] : CarveR[num]);
			int num2 = (shell.bomblet ? DmgR[2] : DmgR[num]);
			int num3 = (shell.bomblet ? (Dmg[2] + 5) : Dmg[num]);
			CreditDug(CarveCircle(cx, cy, r, rim: true));
			FxExplosion(cx, cy, r, shell.weapon);
			for (int i = 0; i < units.Count; i++)
			{
				Unit unit = units[i];
				if (unit.alive)
				{
					int num4 = unit.xQ / 65536;
					int num5 = unit.yQ / 65536 + 5;
					int num6 = num4 - cx;
					int num7 = num5 - cy;
					int num8 = Mathf.RoundToInt(Mathf.Sqrt((float)(num6 * num6 + num7 * num7)));
					if (i == directUnit)
					{
						num8 = 0;
					}
					if (num8 < num2)
					{
						Hurt(unit, num3 * (num2 - num8) / num2);
					}
				}
			}
			if (shell.weapon == Weapon.Molotov && !shell.bomblet)
			{
				for (int j = -4; j <= 4; j++)
				{
					int num9 = cx + j;
					if (num9 >= 1 && num9 < W - 1)
					{
						int num10 = Mathf.Clamp(cy + 3, 2, H - 2);
						int num11 = 0;
						while (num11++ < 12 && num10 > 2 && !Solid(num9, num10 - 1))
						{
							num10--;
						}
						fires.Add(new FireCell
						{
							x = num9,
							y = num10,
							life = 150 + RngRange(0, 30)
						});
					}
				}
			}
			if (shell.weapon == Weapon.GravCube && !shell.bomblet)
			{
				FxImplosion(cx, cy);
				foreach (Unit unit2 in units)
				{
					if (!unit2.alive)
					{
						continue;
					}
					int num12 = unit2.xQ / 65536;
					int num13 = Mathf.Abs(num12 - cx);
					if (num13 == 0 || num13 >= 26)
					{
						continue;
					}
					int num14 = (26 - num13) / 2;
					int num15 = ((num12 < cx) ? 1 : (-1));
					for (int k = 0; k < num14; k++)
					{
						int num16 = num12 + num15;
						if (num16 == cx || num16 < 2 || num16 >= W - 2 || Solid(num16, unit2.yQ / 65536 + 3))
						{
							break;
						}
						num12 = num16;
					}
					unit2.xQ = num12 * 65536;
					PlaceUnitVisual(unit2);
				}
			}
			TryOpenCrate(cx, cy, num2);
			bool num17 = shell.weapon == Weapon.Cluster && !shell.bomblet;
			int xQ = shell.xQ;
			int yQ = shell.yQ;
			RemoveShell(shellIdx);
			if (num17)
			{
				for (int l = 0; l < 5; l++)
				{
					int deg = 90 + (l - 2) * 17 + RngRange(-7, 8);
					int num18 = RngRange(42000, 72000);
					int vxQ = (int)((long)CosDegQ16(deg) * (long)num18 / 65536);
					int vyQ = (int)((long)SinDegQ16(deg) * (long)num18 / 65536);
					SpawnShell(xQ, yQ + 131072, vxQ, vyQ, Weapon.Cluster, bomblet: true);
				}
			}
		}

		private void SettleUnits()
		{
			foreach (Unit unit in units)
			{
				if (!unit.alive)
				{
					continue;
				}
				int x = unit.xQ / 65536;
				int i = unit.yQ / 65536;
				int num = 0;
				for (; i < H - 1 && Solid(x, i); i++)
				{
					if (num++ >= 12)
					{
						break;
					}
				}
				while (i > 1 && !Solid(x, i - 1))
				{
					i--;
				}
				unit.yQ = i * 65536;
				PlaceUnitVisual(unit);
			}
			SettleCrate();
		}

		private void PlaceShellVisual(Shell s)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)s.image).rectTransform.anchoredPosition = new Vector2((float)s.xQ / 65536f * 2f, (float)s.yQ / 65536f * 2f - fieldH * 0.5f);
		}

		private void RestartMatch()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			foreach (Unit unit2 in units)
			{
				unit2.hp = 100;
				unit2.alive = true;
				unit2.ammo = (int[])KitAmmo.Clone();
				((Graphic)unit2.image).color = Color.white;
			}
			fires.Clear();
			fireClock = 0;
			DestroyCrateVisual();
			weapon = Weapon.Bazooka;
			message.Text = "";
			rngState = (rngState ^ (uint)(Environment.TickCount * -1640531535)) | 1;
			for (int i = 0; i < solid.Length; i++)
			{
				solid[i] = 0;
			}
			GenerateTerrain();
			for (int j = 0; j < units.Count; j++)
			{
				Unit unit = units[j];
				int num = W * (j * 2 + 1) / (units.Count * 2) + RngRange(-6, 7);
				unit.xQ = num * 65536;
				unit.yQ = SurfaceYAt(num) * 65536;
				PlaceUnitVisual(unit);
			}
			windLevel = NextWind();
			BeginTurn(0);
		}

		public void End()
		{
			surface?.Destroy();
		}
	}
	internal static class BackgroundSystem
	{
		internal struct Def
		{
			public string name;

			public BgCat cat;

			public Action<Color32[], int, int> paint;

			public Action<Color32[], int, int, float> anim;

			public LiveSkin live;
		}

		private static float[] polarA75;

		private static float[] polarD75;

		private static float[] polarA70;

		private static float[] polarD70;

		private static float[] rainHead;

		private static readonly float[] ripU = new float[3] { 0.3f, 0.72f, 0.52f };

		private static readonly float[] ripQ = new float[3] { 0.52f, 0.78f, 1.1f };

		private static readonly float[] ripP = new float[3] { 0f, 2.4f, 4.4f };

		private static Color32[] magmaBg;

		private static List<Vector2> magmaPts;

		private static List<float> magmaPhase;

		private static readonly int[] cubeEdges = new int[24]
		{
			0, 1, 1, 3, 3, 2, 2, 0, 4, 5,
			5, 7, 7, 6, 6, 4, 0, 4, 1, 5,
			2, 6, 3, 7
		};

		private static readonly float[] cubePu = new float[8];

		private static readonly float[] cubePq = new float[8];

		private static int[] snakePathX;

		private static int[] snakePathY;

		private static byte[] fireHeat;

		private static float fireLastT;

		private static uint fireRng;

		private static Color32[] fireLut;

		private const float FireSimRate = 30f;

		private const int FireCatchup = 40;

		private static readonly float[] lavaS1 = new float[6] { 0.071f, 0.089f, 0.107f, 0.063f, 0.097f, 0.081f };

		private static readonly float[] lavaS2 = new float[6] { 0.053f, 0.067f, 0.045f, 0.078f, 0.059f, 0.091f };

		private static readonly float[] lavaP1 = new float[6] { 0f, 1.3f, 2.9f, 4.1f, 5.2f, 0.7f };

		private static readonly float[] lavaP2 = new float[6] { 2.1f, 0.4f, 3.7f, 1.9f, 5.8f, 4.6f };

		private static readonly float[] lavaR = new float[6] { 0.13f, 0.1f, 0.15f, 0.11f, 0.12f, 0.09f };

		private static readonly float[] lavaBu = new float[6];

		private static readonly float[] lavaBq = new float[6];

		private static readonly float[] lavaBr2 = new float[6];

		private const int TexW = 128;

		private const int TexH = 192;

		private const float AR = 1.5f;

		private static readonly Dictionary<int, Texture2D> cache = new Dictionary<int, Texture2D>();

		public static readonly Def[] Table = BuildTable();

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

		private static Color32[] animScratch;

		private static float lastAnimAt = float.NegativeInfinity;

		private static void AddBatch72Animated(List<Def> t)
		{
			A("Oscilloscope", PaintOscilloscope, 8f);
			A("Radar", PaintRadar, 2.2f);
			A("Heart Monitor", PaintHeartMonitor, 3f);
			A("Digital Rain", PaintDigitalRain, 6f);
			A("Seismograph", PaintSeismograph, 5f);
			A("Spectrum", PaintSpectrum, 4f);
			A("Interference", PaintInterference, 3f);
			A("Caustics", PaintCaustics, 4f);
			A("Thunderstorm", PaintThunderstorm, 2.75f);
			A("Snowfall", PaintSnowfall, 7f);
			A("Orbits", PaintOrbits, 5f);
			A("Black Hole", PaintBlackHole, 3f);
			A("Comet", PaintComet, 6f);
			A("Magma Flow", PaintMagmaFlow, 2f);
			A("Eruption", PaintEruption, 3.1f);
			A("Jellyfish", PaintJellyfish, 4f);
			A("Fireflies", PaintFireflies, 2.4f);
			A("City Lights", PaintCityLights, 5f);
			A("Lighthouse", PaintLighthouse, 1.4f);
			A("Campfire", PaintCampfire, 2f);
			A("Tunnel", PaintTunnel, 6f);
			A("Wireframe", PaintWireframe, 2.6f);
			A("Rotozoom", PaintRotozoom, 3f);
			A("Paddles", PaintPaddles, 3.3f);
			A("Snake", PaintSnake, 4f);
			A("Brickwall", PaintBrickwall, 5f);
			void A(string name, Action<Color32[], int, int, float> anim, float still)
			{
				t.Add(new Def
				{
					name = name,
					cat = BgCat.Pattern,
					anim = anim,
					paint = delegate(Color32[] px, int W, int H)
					{
						anim(px, W, H, still);
					}
				});
			}
		}

		private static void EnsurePolar(ref float[] pa, ref float[] pd, int W, int H, float cq)
		{
			int num = W * H;
			if (pa != null && pa.Length == num)
			{
				return;
			}
			pa = new float[num];
			pd = new float[num];
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num2 = ((float)j + 0.5f) / (float)W;
					float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num4 = num2 - 0.5f;
					float num5 = num3 - cq;
					int num6 = i * W + j;
					pd[num6] = Mathf.Sqrt(num4 * num4 + num5 * num5);
					pa[num6] = Mathf.Atan2(num5, num4);
				}
			}
		}

		private static void PaintOscilloscope(Color32[] px, int W, int H, float t)
		{
			//IL_00c9: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, (j % 21 == 10 || i % 21 == 10) ? C(926738u) : C(397064u));
				}
			}
			float num = t * 0.29f;
			float num2 = t * 0.211f;
			for (int k = 0; k <= 220; k++)
			{
				float num3 = (float)k / 220f * 2f * MathF.PI;
				Disc(px, W, H, 0.5f + 0.36f * Mathf.Sin(3f * num3 + num), (0.75f + 0.52f * Mathf.Sin(2f * num3 + num2)) / 1.5f, 0.011f, C(1194518u));
			}
			for (int l = 0; l <= 220; l++)
			{
				float num4 = (float)l / 220f * 2f * MathF.PI;
				Disc(px, W, H, 0.5f + 0.36f * Mathf.Sin(3f * num4 + num), (0.75f + 0.52f * Mathf.Sin(2f * num4 + num2)) / 1.5f, 0.005f, C(6094708u));
			}
			float num5 = Mathf.Repeat(t * 1.9f, MathF.PI * 2f);
			float cu = 0.5f + 0.36f * Mathf.Sin(3f * num5 + num);
			float num6 = 0.75f + 0.52f * Mathf.Sin(2f * num5 + num2);
			Disc(px, W, H, cu, num6 / 1.5f, 0.012f, C(3111480u));
			Disc(px, W, H, cu, num6 / 1.5f, 0.006f, C(14286815u));
		}

		private static void PaintRadar(Color32[] px, int W, int H, float t)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			EnsurePolar(ref polarA75, ref polarD75, W, H, 0.75f);
			float num = Mathf.Repeat(t * 1.15f, MathF.PI * 2f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					int num2 = i * W + j;
					float num3 = polarD75[num2];
					if (num3 > 0.68f)
					{
						Set(px, W, H, j, i, C(135179u));
						continue;
					}
					float num4 = Mathf.Repeat(num - polarA75[num2], MathF.PI * 2f);
					float num5 = 1f - num4 / 2.4f;
					num5 = ((num5 < 0f) ? 0f : (num5 * num5));
					Color32 val = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(201739u)), Color32.op_Implicit(C(2875499u)), 0.08f + 0.55f * num5));
					float num6 = Mathf.Repeat(num3, 0.17f);
					if (num6 < 0.005f || num6 > 0.165f)
					{
						val = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(val), Color32.op_Implicit(C(1993528u)), 0.6f));
					}
					if (num4 < 0.07f)
					{
						val = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(val), Color32.op_Implicit(C(11861960u)), 1f - num4 / 0.07f));
					}
					Set(px, W, H, j, i, val);
				}
			}
			for (int k = 0; k < 6; k++)
			{
				float num7 = 0.14f + 0.46f * Hash01(k, 1, 6401);
				float num8 = Hash01(k, 2, 6401) * 2f * MathF.PI;
				float num9 = Mathf.Repeat(num - num8, MathF.PI * 2f);
				float num10 = 1f - num9 / 1.6f;
				if (!(num10 <= 0f))
				{
					Disc(px, W, H, 0.5f + Mathf.Cos(num8) * num7, (0.75f + Mathf.Sin(num8) * num7) / 1.5f, 0.008f + 0.01f * num10, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(2875499u)), Color32.op_Implicit(C(15728628u)), num10)));
				}
			}
		}

		private static void PaintHeartMonitor(Color32[] px, int W, int H, float t)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_003a: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, (j % 16 == 0 || i % 16 == 0) ? C(793618u) : C(330248u));
				}
			}
			int num = Mathf.FloorToInt(t * 55f);
			float num2 = Ecg(num - 1);
			for (int k = 0; k < W; k++)
			{
				float num3 = Ecg(k + num);
				int num4 = Mathf.Clamp(Mathf.FloorToInt(Mathf.Min(num2, num3)), 0, H - 1);
				int num5 = Mathf.Clamp(Mathf.CeilToInt(Mathf.Max(num2, num3)), 0, H - 1);
				float num6 = (float)k / (float)W;
				Color32 c = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(1997378u)), Color32.op_Implicit(C(6750112u)), num6 * num6));
				for (int l = num4; l <= num5; l++)
				{
					Set(px, W, H, k, l, c);
				}
				num2 = num3;
			}
			Disc(px, W, H, ((float)W - 7.5f) / (float)W, Ecg(W - 8 + num) / (float)H, 0.014f, C(12124114u));
			static float Bump(float ph, float num8, float w, float a)
			{
				float num7 = Mathf.Abs(ph - num8);
				if (num7 >= w)
				{
					return 0f;
				}
				float num9 = 1f - num7 / w;
				return a * num9 * num9;
			}
			float Ecg(int xw)
			{
				float ph = Mathf.Repeat((float)xw, 132f);
				float num7 = 0f - Bump(ph, 20f, 8f, 5f) + Bump(ph, 44f, 3f, 4f) - Bump(ph, 48f, 4f, 34f) + Bump(ph, 53f, 4f, 9f) - Bump(ph, 84f, 10f, 8f);
				return (float)H * 0.52f + num7 + Mathf.Sin((float)xw * 0.05f) * 1.2f;
			}
		}

		private static void PaintDigitalRain(Color32[] px, int W, int H, float t)
		{
			//IL_00a1: 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_0180: 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_0140: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			int num = W / 6 + 1;
			int num2 = H / 8;
			if (rainHead == null || rainHead.Length != num)
			{
				rainHead = new float[num];
			}
			float[] array = rainHead;
			for (int i = 0; i < num; i++)
			{
				float num3 = 5f + 9f * Hash01(i, 1, 9301);
				array[i] = Mathf.Repeat(t * num3 + Hash01(i, 2, 9301) * 40f, (float)(num2 + 14));
			}
			for (int j = 0; j < H; j++)
			{
				for (int k = 0; k < W; k++)
				{
					int num4 = k / 6;
					int num5 = j / 8;
					float num6 = array[num4] - (float)num5;
					Color32 c = C(198661u);
					if (num6 >= 0f && num6 <= 9f)
					{
						int num7 = k - num4 * 6;
						int num8 = j - num5 * 8;
						if (num7 < 5 && num8 < 7)
						{
							int num9 = Mathf.FloorToInt(t * 2.5f + Hash01(num4, num5, 77) * 4f);
							if (Hash01(num4 * 31 + num7, num5 * 17 + num8, 1000 + num9) > 0.45f)
							{
								c = ((num6 < 1f) ? C(13631453u) : Color32.op_Implicit(Color.Lerp(new Color(0.23f, 0.91f, 0.42f), new Color(0.03f, 0.25f, 0.12f), num6 / 9f)));
							}
						}
					}
					Set(px, W, H, k, j, c);
				}
			}
		}

		private static void PaintSeismograph(Color32[] px, int W, int H, float t)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0038: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.FloorToInt(t * 26f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Color32 c = C(15327948u);
					if ((j + num) % 24 == 0)
					{
						c = C(14664628u);
					}
					if (i % 24 == 12)
					{
						c = C(14273972u);
					}
					Set(px, W, H, j, i, c);
				}
			}
			float num2 = Trace(num - 1);
			for (int k = 0; k < W; k++)
			{
				float num3 = Trace(k + num);
				int num4 = Mathf.Clamp(Mathf.FloorToInt(Mathf.Min(num2, num3)) - 1, 0, H - 1);
				int num5 = Mathf.Clamp(Mathf.CeilToInt(Mathf.Max(num2, num3)) + 1, 0, H - 1);
				for (int l = num4; l <= num5; l++)
				{
					Set(px, W, H, k, l, C(1710626u));
				}
				num2 = num3;
			}
			Disc(px, W, H, ((float)W - 7.5f) / (float)W, Trace(W - 8 + num) / (float)H, 0.018f, C(11546680u));
			float Trace(float xw)
			{
				int num6 = Mathf.FloorToInt(xw / 180f);
				float num7 = xw - (float)num6 * 180f;
				float num8 = ((Hash01(num6, 3, 4501) > 0.5f) ? ((2f + 26f * Hash01(num6, 4, 4501)) / (1f + num7 * num7 * 0.0016f)) : 0f);
				return (float)H * 0.52f + 2.2f * Mathf.Sin(xw * 0.31f) + (Hash01(Mathf.FloorToInt(xw), 5, 4501) - 0.5f) * 2f + num8 * Mathf.Sin(xw * 1.35f);
			}
		}

		private static void PaintSpectrum(Color32[] px, int W, int H, float t)
		{
			//IL_0008: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			Fill(px, W, H, C(657938u));
			float tt = Mathf.Floor(t * 2.5f) / 2.5f;
			int i;
			for (i = 0; i < 14; i++)
			{
				float num = Level(t);
				float u = 0.03f + (float)i * 0.06714286f + 0.004f;
				float u2 = 0.03f + (float)(i + 1) * 0.06714286f - 0.004f;
				int num2 = Mathf.FloorToInt(num / 0.043f);
				for (int j = 0; j < num2; j++)
				{
					float num3 = 0.97f - (float)j * 0.043f;
					Band(px, W, H, u, num3 - 0.033f, u2, num3, C((j < 7) ? 2873704u : ((j < 10) ? 15259720u : 14701896u)));
				}
				float num4 = Mathf.Max(Level(tt), num) + 0.015f;
				Band(px, W, H, u, 0.97f - num4 - 0.008f, u2, 0.97f - num4, C(14214376u));
			}
			float Level(float num5)
			{
				return 0.1f + 0.55f * Mathf.Abs(Mathf.Sin(num5 * 1.7f + (float)i * 0.9f) * 0.5f + Mathf.Sin(num5 * 2.3f + (float)i * 1.7f) * 0.35f + Mathf.Sin(num5 * 0.9f + (float)i * 0.4f) * 0.15f);
			}
		}

		private static void PaintInterference(Color32[] px, int W, int H, float t)
		{
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(0.031f, 0.078f, 0.165f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.118f, 0.306f, 0.557f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.604f, 0.831f, 1f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num = ((float)j + 0.5f) / (float)W;
					float num2 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num3 = 0f;
					for (int k = 0; k < 3; k++)
					{
						float num4 = num - ripU[k];
						float num5 = num2 - ripQ[k];
						float num6 = Mathf.Sqrt(num4 * num4 + num5 * num5);
						num3 += Mathf.Sin(num6 * 46f - t * 2.1f + ripP[k]) / (1f + num6 * 5f);
					}
					float num7 = Mathf.Clamp01(num3 * 0.42f + 0.5f);
					Color32 c = Color32.op_Implicit((num7 < 0.5f) ? Color.Lerp(val, val2, num7 * 2f) : Color.Lerp(val2, val3, (num7 - 0.5f) * 2f));
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void PaintCaustics(Color32[] px, int W, int H, float t)
		{
			//IL_00eb: 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_00f8: 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_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_0128: 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_01ea: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(0.043f, 0.22f, 0.259f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.016f, 0.11f, 0.149f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num = ((float)j + 0.5f) / (float)W;
					float num2 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num3 = Mathf.Sin(num * 7.3f + t * 0.61f + 1.4f * Mathf.Sin(num2 * 3.1f - t * 0.43f));
					float num4 = Mathf.Sin(num2 * 6.1f - t * 0.53f + 1.3f * Mathf.Sin(num * 4.7f + t * 0.37f));
					float num5 = 1f - Mathf.Abs((num3 + num4) * 0.5f);
					float num6 = num5 * num5;
					float num7 = num6 * num6 * (1.15f - num2 * 0.45f);
					Color32 c = Color32.op_Implicit(Color.Lerp(Color.Lerp(val, val2, ((float)i + 0.5f) / (float)H), new Color(0.659f, 0.933f, 0.894f), Mathf.Clamp01(num7) * 0.85f));
					Set(px, W, H, j, i, c);
				}
			}
			for (int k = 0; k < 12; k++)
			{
				float num8 = 0.05f + 0.06f * Hash01(k, 1, 5601);
				float cv = 1.05f - Mathf.Repeat(t * num8 + Hash01(k, 2, 5601) * 1.25f, 1.25f);
				float cu = Hash01(k, 3, 5601) + 0.02f * Mathf.Sin(t * 1.3f + (float)k * 2.2f);
				Disc(px, W, H, cu, cv, 0.003f + 0.004f * Hash01(k, 4, 5601), C(10475728u));
			}
		}

		private static void PaintThunderstorm(Color32[] px, int W, int H, float t)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_0098: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: 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_0192: 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_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.FloorToInt(t / 2.7f);
			float num2 = t - (float)num * 2.7f;
			float num3 = ((num2 < 0.18f) ? ((1f - num2 / 0.18f) * 0.55f) : 0f);
			Color val = Color.Lerp(new Color(0.043f, 0.059f, 0.102f), new Color(0.224f, 0.278f, 0.42f), num3);
			Color val2 = Color.Lerp(new Color(0.102f, 0.125f, 0.188f), new Color(0.278f, 0.333f, 0.478f), num3);
			for (int i = 0; i < H; i++)
			{
				Color32 c = Color32.op_Implicit(Color.Lerp(val, val2, ((float)i + 0.5f) / (float)H));
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
			for (int k = 0; k < 12; k++)
			{
				float cu = Hash01(k, 3, 8801) * 1.1f - 0.05f;
				float num4 = 0.02f + 0.09f * Hash01(k, 4, 8801);
				float num5 = 0.07f + 0.07f * Hash01(k, 5, 8801);
				Disc(px, W, H, cu, num4 + 0.012f, num5, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(1777974u)), Color32.op_Implicit(C(4082286u)), num3)));
				Disc(px, W, H, cu, num4, num5 * 0.92f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(922144u)), Color32.op_Implicit(C(3028562u)), num3)));
			}
			if (num2 < 0.35f)
			{
				float num6 = 0.2f + 0.6f * Hash01(num, 1, 8801);
				float num7 = 0.2f;
				for (int l = 0; l < 12; l++)
				{
					float num8 = num6 + (Hash01(num, 10 + l, 8801) - 0.5f) * 0.09f;
					float num9 = num7 + 0.095f;
					StampLine(px, W, H, num6, num7, num8, num9, 0.01f, C(5136014u), 8);
					StampLine(px, W, H, num6, num7, num8, num9, 0.004f, C(15725823u), 8);
					if (l == 5)
					{
						float u = num8 + (Hash01(num, 30, 8801) - 0.5f) * 0.3f;
						StampLine(px, W, H, num8, num9, u, num9 + 0.22f, 0.003f, C(11453160u), 10);
					}
					num6 = num8;
					num7 = num9;
				}
			}
			for (int m = 0; m < 80; m++)
			{
				float num10 = Hash01(m, 6, 8801) * 1.05f;
				float num11 = Mathf.Repeat(t * 1.9f + Hash01(m, 7, 8801), 1f) * 1.55f - 0.1f;
				bool flag = m % 3 == 0;
				StampLine(px, W, H, num10 - 0.012f, num11 - 0.055f, num10, num11, flag ? 0.0035f : 0.0025f, C(flag ? 4215418u : 2767452u), 4);
			}
		}

		private static void PaintSnowfall(Color32[] px, int W, int H, float t)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 857638u, 1780288u);
			for (int i = 0; i < W; i++)
			{
				float num = ((float)i + 0.5f) / (float)W;
				int num2 = Mathf.FloorToInt((0.88f + 0.03f * Mathf.Sin(num * 5.2f + 1f)) * (float)H);
				for (int j = Mathf.Max(0, num2); j < H; j++)
				{
					Set(px, W, H, i, j, C(12175068u));
				}
			}
			for (int k = 0; k < 3; k++)
			{
				int num3 = k switch
				{
					1 => 40, 
					0 => 50, 
					_ => 28, 
				};
				float r = 0.0035f + (float)k * 0.002f;
				float num4 = 0.06f + (float)k * 0.035f;
				uint rgb = k switch
				{
					1 => 10465480u, 
					0 => 7241370u, 
					_ => 15134456u, 
				};
				for (int l = 0; l < num3; l++)
				{
					float num5 = Hash01(l, k, 7601);
					float cv = Mathf.Repeat(t * num4 + num5 * 1.12f, 1.12f) - 0.06f;
					float cu = Hash01(l, k + 9, 7601) + (0.015f + 0.01f * (float)k) * Mathf.Sin(t * 0.9f + num5 * 7f);
					Disc(px, W, H, cu, cv, r, C(rgb));
				}
			}
		}

		private static void PaintOrbits(Color32[] px, int W, int H, float t)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			Fill(px, W, H, C(329487u));
			SpeckleDiscs(px, W, H, 6101, 60, 0.0015f, 0.004f, new uint[2] { 3820142u, 7242412u });
			float[] array = new float[4] { 0.14f, 0.22f, 0.31f, 0.43f };
			float[] array2 = new float[4] { 1.9f, 1.2f, 0.75f, 0.5f };
			uint[] array3 = new uint[4] { 13130302u, 5152952u, 14201930u, 9080736u };
			float[] array4 = new float[4] { 0.012f, 0.016f, 0.02f, 0.009f };
			float[] array5 = array;
			foreach (float r in array5)
			{
				Ring(px, W, H, 0.5f, 34f / 75f, r, 0.0035f, C(1317418u));
			}
			Disc(px, W, H, 0.5f, 34f / 75f, 0.09f, C(3811856u));
			Disc(px, W, H, 0.5f, 34f / 75f, 0.06f, C(8016408u));
			Disc(px, W, H, 0.5f, 34f / 75f, 0.035f, C(16767082u));
			Disc(px, W, H, 0.5f, 34f / 75f, 0.02f, C(16773824u));
			for (int j = 0; j < 4; j++)
			{
				float num = t * array2[j] + (float)j * 1.9f;
				for (int num2 = 5; num2 >= 1; num2--)
				{
					float num3 = num - (float)num2 * 0.09f;
					Disc(px, W, H, 0.5f + Mathf.Cos(num3) * array[j], (0.68f + Mathf.Sin(num3) * array[j]) / 1.5f, array4[j] * (1f - (float)num2 * 0.13f), Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(array3[j])), Color32.op_Implicit(C(329487u)), (float)num2 / 6f)));
				}
				float num4 = 0.5f + Mathf.Cos(num) * array[j];
				float num5 = 0.68f + Mathf.Sin(num) * array[j];
				Disc(px, W, H, num4, num5 / 1.5f, array4[j], C(array3[j]));
				if (j == 2)
				{
					Disc(px, W, H, num4 + 0.004f, (num5 - 0.004f) / 1.5f, array4[j] * 0.72f, C(12096058u));
				}
				if (j == 1)
				{
					float num6 = t * 4.2f;
					Disc(px, W, H, num4 + Mathf.Cos(num6) * 0.032f, (num5 + Mathf.Sin(num6) * 0.032f) / 1.5f, 0.005f, C(12175068u));
				}
			}
		}

		private static void PaintBlackHole(Color32[] px, int W, int H, float t)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: 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_017e: 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_0188: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			EnsurePolar(ref polarA70, ref polarD70, W, H, 0.7f);
			Color val = default(Color);
			((Color)(ref val))..ctor(0.102f, 0.047f, 0.024f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.91f, 0.416f, 0.118f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(1f, 0.941f, 0.816f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					int num = i * W + j;
					float num2 = polarD70[num];
					Color32 c;
					if (num2 < 0.055f)
					{
						c = C(0u);
					}
					else if (Mathf.Abs(num2 - 0.068f) < 0.006f)
					{
						c = C(16771266u);
					}
					else
					{
						float num3 = 1f - Mathf.Abs(num2 - 0.21f) / 0.13f;
						if (num3 <= 0f)
						{
							c = C(197642u);
						}
						else
						{
							float num4 = polarA70[num];
							float num5 = 0.5f + 0.5f * Mathf.Sin(num4 * 3f + num2 * 34f - t * 1.6f);
							float num6 = 0.65f + 0.35f * Mathf.Sin(num4 - 0.4f);
							float num7 = Mathf.Clamp01(num3 * num3 * (0.35f + 0.65f * num5) * num6 * 1.35f);
							c = Color32.op_Implicit((num7 < 0.5f) ? Color.Lerp(val, val2, num7 * 2f) : Color.Lerp(val2, val3, (num7 - 0.5f) * 2f));
							if (num7 < 0.04f)
							{
								c = C(197642u);
							}
						}
					}
					Set(px, W, H, j, i, c);
				}
			}
			SpeckleDiscs(px, W, H, 6301, 40, 0.0015f, 0.0035f, new uint[2] { 3820142u, 7242412u });
		}

		private static void PaintComet(Color32[] px, int W, int H, float t)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			Fill(px, W, H, C(263695u));
			SpeckleDiscs(px, W, H, 6201, 90, 0.0015f, 0.004f, new uint[3] { 9413572u, 5334156u, 3820142u });
			float num = Mathf.Repeat(t / 9f, 1f);
			for (int num2 = 30; num2 >= 1; num2--)
			{
				float pp = num - (float)num2 * 0.012f;
				float num3 = (float)num2 / 30f;
				float num4 = (Hash01(num2, 1, 6202) - 0.5f) * 0.02f * num3;
				Disc(px, W, H, U(pp) + num4, (Q(pp) - num4 * 0.7f) / 1.5f, 0.012f * (1f - num3) + 0.002f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(10469608u)), Color32.op_Implicit(C(659488u)), num3)));
			}
			Disc(px, W, H, U(num), Q(num) / 1.5f, 0.024f, C(5140136u));
			Disc(px, W, H, U(num), Q(num) / 1.5f, 0.014f, C(12572916u));
			Disc(px, W, H, U(num), Q(num) / 1.5f, 0.008f, C(15923455u));
			static float Q(float num5)
			{
				return 0.25f + 0.9f * num5 + 0.15f * Mathf.Sin(num5 * 3f);
			}
			static float U(float num5)
			{
				return -0.2f + 1.4f * num5;
			}
		}

		private static void PaintMagmaFlow(Color32[] px, int W, int H, float t)
		{
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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_019c: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00d5: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			int num = W * H;
			Random rng;
			if (magmaBg == null || magmaBg.Length != num)
			{
				magmaBg = (Color32[])(object)new Color32[num];
				BlockNoise(magmaBg, W, H, 7801, 16, new uint[4] { 1643537u, 1972243u, 1380624u, 2234900u });
				magmaPts = new List<Vector2>();
				magmaPhase = new List<float>();
				rng = new Random(7802);
				for (int i = 0; i < 5; i++)
				{
					Walk(0.08f + 0.84f * (float)rng.NextDouble(), 0.32999998f * (float)rng.NextDouble(), MathF.PI / 2f, 62, (float)i * 2.3f);
				}
				foreach (Vector2 magmaPt in magmaPts)
				{
					Disc(magmaBg, W, H, magmaPt.x, magmaPt.y / 1.5f, 0.018f, C(2755588u));
				}
				SpeckleDiscs(magmaBg, W, H, 7803, 24, 0.002f, 0.005f, new uint[2] { 5379589u, 7217162u });
			}
			Array.Copy(magmaBg, px, num);
			for (int j = 0; j < magmaPts.Count; j++)
			{
				float num2 = 0.5f + 0.5f * Mathf.Sin(magmaPhase[j] - t * 2.6f);
				Vector2 val = magmaPts[j];
				Disc(px, W, H, val.x, val.y / 1.5f, 0.009f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(5379589u)), Color32.op_Implicit(C(16761418u)), num2 * num2)));
				if (num2 > 0.8f)
				{
					Disc(px, W, H, val.x, val.y / 1.5f, 0.0045f, C(16771496u));
				}
			}
			void Walk(float u, float q, float a, int steps, float ph0)
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				for (int k = 0; k < steps; k++)
				{
					a += ((float)rng.NextDouble() - 0.5f) * 0.9f;
					a = Mathf.Clamp(a, 0.47079635f, 2.6707964f);
					u += Mathf.Cos(a) * 0.016f;
					q += Mathf.Sin(a) * 0.016f;
					magmaPts.Add(new Vector2(u, q));
					magmaPhase.Add(ph0 + (float)k * 0.5f);
				}
			}
		}

		private static void PaintEruption(Color32[] px, int W, int H, float t)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_013e: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 722960u, 2757136u);
			SpeckleDiscs(px, W, H, 6501, 30, 0.0015f, 0.003f, new uint[2] { 5128798u, 7232110u });
			for (int i = 0; i < 4; i++)
			{
				float num = Mathf.Repeat(t * 0.12f + Hash01(i, 1, 6501), 1f);
				Disc(px, W, H, 0.52f + (Hash01(i, 2, 6501) - 0.5f) * 0.16f * num, (0.6f - num * 0.45f) / 1.5f, 0.02f + num * 0.06f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(2761777u)), Color32.op_Implicit(C(722960u)), num)));
			}
			Tri(px, W, H, new Vector2(0.06f, 1.02f), new Vector2(0.96f, 1.02f), new Vector2(0.52f, 0.44f), C(1182987u));
			Tri(px, W, H, new Vector2(0.44f, 0.435f), new Vector2(0.6f, 0.435f), new Vector2(0.52f, 0.52f), C(722960u));
			Disc(px, W, H, 0.52f, 0.45f, 0.05f, C(8266760u));
			Disc(px, W, H, 0.52f, 0.45f, 0.028f, C(16742946u));
			for (int j = 0; j < 2; j++)
			{
				float num2 = ((j == 0) ? (-1f) : 1f);
				float u = 0.52f;
				float q = 0.7f;
				for (int k = 1; k < 30; k++)
				{
					float num3 = (float)k / 29f;
					float num4 = 0.5f + 0.5f * Mathf.Sin((float)k * 0.45f - t * 4f + (float)j * 2f);
					float num5 = 0.52f + num2 * (0.02f + num3 * 0.185f);
					float num6 = 0.7f + num3 * 0.72f;
					StampLine(px, W, H, u, q, num5, num6, 0.005f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(8266760u)), Color32.op_Implicit(C(16751164u)), num4)), 3);
					u = num5;
					q = num6;
				}
				for (int l = 0; l < 6; l++)
				{
					float num7 = Mathf.Repeat(t * 0.35f + (float)l / 6f + (float)j * 0.5f, 1f);
					Disc(px, W, H, 0.52f + num2 * (0.02f + num7 * 0.185f), (0.7f + num7 * 0.72f) / 1.5f, 0.004f, C(16771496u));
				}
			}
			for (int m = 0; m < 60; m++)
			{
				float num8 = Hash01(m, 3, 6501);
				float num9 = Hash01(m, 4, 6501);
				float num10 = Hash01(m, 5, 6501);
				float num11 = MathF.PI / 2f + (num8 - 0.5f) * 1f;
				float num12 = 0.55f + 0.35f * num9;
				float num13 = Mathf.Repeat(t / (1.7f + 0.6f * num10) + num8 * 0.9f, 1f);
				float cu = 0.52f + Mathf.Cos(num11) * num12 * 0.35f * num13;
				float num14 = 0.66f - Mathf.Sin(num11) * num12 * num13 + 0.62f * num13 * num13;
				if (!(num14 > 0.72f))
				{
					uint rgb = ((num13 < 0.3f) ? 16771496u : ((num13 < 0.6f) ? 16747054u : 10369552u));
					Disc(px, W, H, cu, num14 / 1.5f, 0.011f * (1f - num13 * 0.5f), C(rgb));
				}
			}
		}

		private static Color32 SeaAt(float v)
		{
			//IL_000f: 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)
			//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 Color32.op_Implicit(Color.Lerp(new Color(0.016f, 0.063f, 0.133f), new Color(0.039f, 0.125f, 0.212f), v));
		}

		private static void PaintJellyfish(Color32[] px, int W, int H, float t)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: 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)
			for (int i = 0; i < H; i++)
			{
				Color32 c = SeaAt(((float)i + 0.5f) / (float)H);
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
			for (int k = 0; k < 20; k++)
			{
				float cu = Hash01(k, 1, 5901) + 0.01f * Mathf.Sin(t * 0.4f + (float)k);
				float cv = Mathf.Repeat(Hash01(k, 2, 5901) + t * 0.008f, 1f);
				Disc(px, W, H, cu, cv, 0.002f, C(3037816u));
			}
			float num = 0.52f + 0.02f * Mathf.Sin(t * 1.1f);
			float num2 = 0.14f * (1f + 0.05f * Mathf.Sin(t * 1.3f - 0.5f));
			for (int l = 0; l < 6; l++)
			{
				float num3 = 0.5f + ((float)l - 2.5f) * 0.034f;
				float u = num3;
				float q = num + 0.05f;
				for (int m = 1; m <= 15; m++)
				{
					float num4 = num + 0.05f + (float)m * 0.036f;
					float num5 = num3 + Mathf.Sin(num4 * 9f - t * 1.7f + (float)l * 1.1f) * 0.016f * ((float)m / 15f + 0.3f);
					StampLine(px, W, H, u, q, num5, num4, (l % 3 == 1) ? 0.005f : 0.0035f, C((l % 3 == 1) ? 6201032u : 3829912u), 3);
					u = num5;
					q = num4;
				}
			}
			Disc(px, W, H, 0.5f, num / 1.5f, num2, C(3039880u));
			Disc(px, W, H, 0.5f, (num - 0.015f) / 1.5f, num2 * 0.8f, C(5148600u));
			Disc(px, W, H, 0.5f, (num - 0.03f) / 1.5f, num2 * 0.55f, C(8372448u));
			for (int n = 0; n < 4; n++)
			{
				float cu2 = 0.5f + ((float)n - 1.5f) * num2 * 0.55f;
				float num6 = num + num2 * 0.72f;
				Disc(px, W, H, cu2, num6 / 1.5f, num2 * 0.34f, SeaAt(num6 / 1.5f));
			}
			Disc(px, W, H, 0.46f, (num - 0.05f) / 1.5f, 0.012f, C(12117240u));
			Disc(px, W, H, 0.55f, (num - 0.02f) / 1.5f, 0.008f, C(10868976u));
		}

		private static void PaintFireflies(Color32[] px, int W, int H, float t)
		{
			//IL_0093: 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_00be: 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_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 1056294u, 1714716u);
			for (int i = 0; i < W; i++)
			{
				float num = ((float)i + 0.5f) / (float)W;
				int num2 = Mathf.FloorToInt((0.55f + 0.07f * Fbm(num * 3.1f, 0.7f, 5801, 2)) * (float)H);
				int num3 = Mathf.FloorToInt((0.8f + 0.06f * Fbm(num * 4.3f, 3.9f, 5801, 2)) * (float)H);
				for (int j = Mathf.Max(0, num2); j < H; j++)
				{
					Set(px, W, H, i, j, C(792336u));
				}
				for (int k = Mathf.Max(0, num3); k < H; k++)
				{
					Set(px, W, H, i, k, C(462857u));
				}
			}
			for (int l = 0; l < 18; l++)
			{
				float num4 = Hash01(l, 1, 5802);
				float num5 = 0.05f + 0.05f * Hash01(l, 2, 5802);
				StampLine(px, W, H, num4, 1.485f, num4 + 0.015f * Mathf.Sin((float)l + t * 0.3f), 1.5f * (0.99f - num5), 0.0025f, C(1057300u), 6);
			}
			for (int m = 0; m < 22; m++)
			{
				float num6 = 0.08f + 0.84f * Hash01(m, 3, 5803);
				float num7 = 0.55f + 0.75f * Hash01(m, 4, 5803);
				float cu = num6 + 0.1f * Mathf.Sin(t * (0.21f + 0.1f * Hash01(m, 5, 5803)) + (float)m * 2.7f);
				float num8 = num7 + 0.07f * Mathf.Sin(t * (0.17f + 0.08f * Hash01(m, 6, 5803)) + (float)m * 1.3f);
				float num9 = 0.5f + 0.5f * Mathf.Sin(t * 0.7f + (float)m * 2.1f);
				num9 *= num9;
				Disc(px, W, H, cu, num8 / 1.5f, 0.016f + 0.01f * num9, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(1581583u)), Color32.op_Implicit(C(5597470u)), num9)));
				Disc(px, W, H, cu, num8 / 1.5f, 0.006f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(9083454u)), Color32.op_Implicit(C(16318384u)), num9)));
			}
		}

		private static void PaintCityLights(Color32[] px, int W, int H, float t)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 658974u, 2760752u);
			SpeckleDiscs(px, W, H, 5701, 40, 0.0012f, 0.003f, new uint[2] { 9413572u, 6058400u });
			Disc(px, W, H, 0.2f, 0.14f, 0.035f, C(14278892u));
			Disc(px, W, H, 0.187f, 0.128f, 0.026f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(658974u)), Color32.op_Implicit(C(2760752u)), 0.21000001f)));
			float num = 0f;
			float num2 = 0f;
			float cu = 0f;
			int num3 = 0;
			while (num < 1f && num3 < 14)
			{
				float num4 = 0.07f + 0.09f * Hash01(num3, 1, 5702);
				float num5 = 0.3f + 0.45f * Hash01(num3, 2, 5702);
				float num6 = Mathf.Min(1f, num + num4);
				Band(px, W, H, num, 1f - num5, num6, 1f, C(724760u));
				if (num5 > num2)
				{
					num2 = num5;
					cu = (num + num6) * 0.5f;
				}
				int num7 = 0;
				float num8 = num + 0.014f;
				while (num8 < num6 - 0.02f)
				{
					int num9 = 0;
					float num10 = 1f - num5 + 0.018f;
					while (num10 < 0.97f)
					{
						int num11 = Mathf.FloorToInt(t * 0.45f + Hash01(num3 * 31 + num7, num9, 555) * 5f);
						uint rgb = ((Hash01(num3 * 131 + num7, num9 * 17, 900 + num11) > 0.62f) ? ((Hash01(num3 + num7, num9, 42) > 0.3f) ? 15254634u : 10467544u) : 1119260u);
						Band(px, W, H, num8, num10, num8 + 0.013f, num10 + 0.016f, C(rgb));
						num10 += 0.03f;
						num9++;
					}
					num8 += 0.027f;
					num7++;
				}
				num = num6 + 0.006f;
				num3++;
			}
			if (Mathf.Sin(t * 2.2f) > 0.55f)
			{
				Disc(px, W, H, cu, 1f - num2 - 0.012f, 0.006f, C(14698568u));
			}
		}

		private static void PaintLighthouse(Color32[] px, int W, int H, float t)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: 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_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: 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_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 659488u, 1713208u);
			SpeckleDiscs(px, W, H, 5501, 40, 0.0012f, 0.003f, new uint[2] { 9413572u, 5334156u });
			Band(px, W, H, 0f, 0.6f, 1f, 1f, C(661542u));
			for (int i = 0; i < 10; i++)
			{
				float num = 0.63f + (float)i * 0.037f;
				for (int j = 0; j < W; j++)
				{
					if (Mathf.Sin(((float)j + 0.5f) / (float)W * 22f + t * 1.1f + (float)i * 2.1f) > 0.88f)
					{
						Set(px, W, H, j, Mathf.FloorToInt(num * (float)H), C(1981012u));
					}
				}
			}
			float num2 = Mathf.Repeat(t * 0.65f, MathF.PI * 2f);
			for (int k = 0; k < 2; k++)
			{
				float num3 = num2 + (float)k * MathF.PI;
				float num4 = Mathf.Cos(num3);
				float num5 = Mathf.Sin(num3) * 0.35f;
				for (int l = 1; l <= 26; l++)
				{
					float num6 = (float)l / 26f * 0.95f;
					Disc(px, W, H, 0.74f + num4 * num6, (0.4f + num5 * num6) / 1.5f, 0.004f + num6 * 0.045f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(16774344u)), Color32.op_Implicit(C(2633802u)), num6 * 1.05f)));
				}
			}
			Disc(px, W, H, 0.74f, 0.98f, 0.1f, C(856084u));
			Disc(px, W, H, 0.66f, 1.02f, 0.09f, C(658705u));
			Band(px, W, H, 0.705f, 0.3f, 0.775f, 0.66f, C(13159636u));
			Band(px, W, H, 0.705f, 0.36f, 0.775f, 0.44f, C(11546680u));
			Band(px, W, H, 0.705f, 0.52f, 0.775f, 0.6f, C(11546680u));
			Band(px, W, H, 0.69f, 0.285f, 0.79f, 0.305f, C(2237998u));
			Band(px, W, H, 0.715f, 0.235f, 0.765f, 0.285f, C(1316894u));
			Band(px, W, H, 0.7f, 0.215f, 0.78f, 0.235f, C(2764342u));
			Disc(px, W, H, 0.74f, 4f / 15f, 0.02f, C(16774864u));
			Disc(px, W, H, 0.74f, 4f / 15f, 0.01f, C(16777215u));
		}

		private static void PaintCampfire(Color32[] px, int W, int H, float t)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_008d: 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_00ab: 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_00cc: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_013b: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: 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_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: 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_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 658970u, 1183252u);
			SpeckleDiscs(px, W, H, 7301, 40, 0.0012f, 0.003f, new uint[2] { 7242412u, 4478062u });
			Tri(px, W, H, new Vector2(-0.04f, 1.02f), new Vector2(0.24f, 1.02f), new Vector2(0.1f, 0.38f), C(461330u));
			Tri(px, W, H, new Vector2(0.76f, 1.02f), new Vector2(1.04f, 1.02f), new Vector2(0.9f, 0.3f), C(461330u));
			Tri(px, W, H, new Vector2(0.62f, 1.02f), new Vector2(0.86f, 1.02f), new Vector2(0.74f, 0.58f), C(527381u));
			Band(px, W, H, 0f, 0.92f, 1f, 1f, C(723472u));
			Disc(px, W, H, 0.5f, 0.905f, 0.22f, C(2364424u));
			Disc(px, W, H, 0.5f, 0.905f, 0.13f, C(3810320u));
			StampLine(px, W, H, 0.4f, 1.42f, 0.6f, 1.36f, 0.012f, C(2758672u), 10);
			StampLine(px, W, H, 0.42f, 1.36f, 0.58f, 1.42f, 0.012f, C(1970696u), 10);
			int x = Mathf.FloorToInt(t * 9f);
			float num = Hash01(x, 1, 7302);
			float num2 = Hash01(x, 2, 7302);
			float num3 = Hash01(x, 3, 7302);
			Tri(px, W, H, new Vector2(0.438f, 0.935f), new Vector2(0.562f, 0.935f), new Vector2(0.5f + (num - 0.5f) * 0.06f, 0.72f + num2 * 0.05f), C(12732948u));
			Tri(px, W, H, new Vector2(0.458f, 0.935f), new Vector2(0.542f, 0.935f), new Vector2(0.5f + (num2 - 0.5f) * 0.045f, 0.775f + num3 * 0.04f), C(16751164u));
			Tri(px, W, H, new Vector2(0.476f, 0.935f), new Vector2(0.524f, 0.935f), new Vector2(0.5f + (num3 - 0.5f) * 0.03f, 0.83f + num * 0.03f), C(16771496u));
			for (int i = 0; i < 9; i++)
			{
				float num4 = Mathf.Repeat(t * 0.7f + Hash01(i, 4, 7302), 1f);
				float cu = 0.5f + (Hash01(i, 5, 7302) - 0.5f) * 0.08f + 0.03f * Mathf.Sin(t * 2f + (float)i);
				Disc(px, W, H, cu, 0.9f - num4 * 0.55f, 0.003f, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(16761418u)), Color32.op_Implicit(C(8266760u)), num4)));
			}
		}

		private static void PaintTunnel(Color32[] px, int W, int H, float t)
		{
			//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_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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			EnsurePolar(ref polarA75, ref polarD75, W, H, 0.75f);
			int num = Mathf.RoundToInt(0.06f * Mathf.Sin(t * 0.4f) * (float)W);
			int num2 = Mathf.RoundToInt(0.09f * Mathf.Cos(t * 0.31f) / 1.5f * (float)H);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					int num3 = Mathf.Clamp(j - num, 0, W - 1);
					int num4 = Mathf.Clamp(i - num2, 0, H - 1) * W + num3;
					float num5 = Mathf.Max(polarD75[num4], 0.03f);
					float num6 = (polarA75[num4] / (MathF.PI * 2f) + 0.5f) * 12f + t * 0.35f;
					float num7 = 0.42f / num5 - t * 2.1f;
					bool flag = ((Mathf.FloorToInt(num6) + Mathf.FloorToInt(num7)) & 1) == 0;
					float num8 = Mathf.Clamp01(num5 * 2.2f);
					Color32 val = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(328458u)), Color32.op_Implicit(C(flag ? 5120896u : 1313316u)), num8));
					float num9 = num7 - Mathf.Floor(num7);
					if (num9 < 0.12f)
					{
						val = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(val), Color32.op_Implicit(C(10247167u)), num8 * (1f - num9 / 0.12f) * 0.8f));
					}
					Set(px, W, H, j, i, val);
				}
			}
		}

		private static void PaintWireframe(Color32[] px, int W, int H, float t)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Fill(px, W, H, C(263692u));
			SpeckleDiscs(px, W, H, 5401, 30, 0.0012f, 0.003f, new uint[2] { 2767444u, 4478062u });
			Cube(0.07f, (0f - t) * 0.9f, t * 0.5f + 0.7f, 663592u, 2252910u, 0.0025f);
			Cube(0.17f, t * 0.7f, t * 0.32f, 932424u, 5433599u, 0.0038f);
			void Cube(float scale, float ry, float rx, uint glow, uint core, float coreR)
			{
				//IL_0125: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
				float[] array = cubePu;
				float[] array2 = cubePq;
				float num = Mathf.Sin(ry);
				float num2 = Mathf.Cos(ry);
				float num3 = Mathf.Sin(rx);
				float num4 = Mathf.Cos(rx);
				for (int i = 0; i < 8; i++)
				{
					float num5 = (((i & 1) == 0) ? (-1f) : 1f);
					float num6 = (((i & 2) == 0) ? (-1f) : 1f);
					float num7 = (((i & 4) == 0) ? (-1f) : 1f);
					float num8 = num5 * num2 + num7 * num;
					float num9 = (0f - num5) * num + num7 * num2;
					float num10 = num6 * num4 - num9 * num3;
					float num11 = (num6 * num3 + num9 * num4) * scale + 3.2f;
					array[i] = 0.5f + num8 * scale * 2.6f / num11;
					array2[i] = 0.72f + num10 * scale * 2.6f / num11;
				}
				int[] array3 = cubeEdges;
				for (int j = 0; j < array3.Length; j += 2)
				{
					StampLine(px, W, H, array[array3[j]], array2[array3[j]], array[array3[j + 1]], array2[array3[j + 1]], 0.007f, C(glow), 48);
				}
				for (int k = 0; k < array3.Length; k += 2)
				{
					StampLine(px, W, H, array[array3[k]], array2[array3[k]], array[array3[k + 1]], array2[array3[k + 1]], coreR, C(core), 48);
				}
				for (int l = 0; l < 8; l++)
				{
					Disc(px, W, H, array[l], array2[l] / 1.5f, coreR * 1.9f, C(core));
				}
			}
		}

		private static void PaintRotozoom(Color32[] px, int W, int H, float t)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			float num = t * 0.45f;
			float num2 = Mathf.Cos(num);
			float num3 = Mathf.Sin(num);
			float num4 = 1.6f + 0.8f * Mathf.Sin(t * 0.31f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num5 = ((float)j + 0.5f) / (float)W;
					float num6 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num7 = num5 - 0.5f;
					float num8 = num6 - 0.75f;
					float num9 = (num7 * num2 - num8 * num3) * num4;
					float num10 = (num7 * num3 + num8 * num2) * num4;
					bool flag = ((Mathf.FloorToInt(num9 * 5f + 100f) + Mathf.FloorToInt(num10 * 5f + 100f)) & 1) == 0;
					float num11 = Mathf.Clamp01(1.15f - Mathf.Sqrt(num7 * num7 + num8 * num8) * 0.9f);
					Set(px, W, H, j, i, Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(656900u)), Color32.op_Implicit(C(flag ? 11754258u : 2364936u)), num11)));
				}
			}
		}

		private static float Tri01(float p)
		{
			float num = Mathf.Repeat(p, 2f);
			if (!(num < 1f))
			{
				return 2f - num;
			}
			return num;
		}

		private static void PaintPaddles(Color32[] px, int W, int H, float t)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, (i % 3 == 0) ? C(197637u) : C(329482u));
				}
			}
			for (float num = 0.03f; num < 1f; num += 0.075f)
			{
				Band(px, W, H, 0.494f, num, 0.506f, num + 0.038f, C(2764342u));
			}
			float num2 = 0.09f + 0.82f * Tri01(t * 0.63f);
			float num3 = 0.16f + 1.18f * Tri01(t * 0.41f + 0.27f);
			float num4 = 0.16f + 1.18f * Tri01(t * 0.41f + 0.27f - 0.045f);
			float num5 = 0.16f + 1.18f * Tri01(t * 0.41f + 0.27f + 0.045f);
			Paddle(0.055f, Mathf.Clamp(num4, 0.25f, 1.35f));
			Paddle(0.945f, Mathf.Clamp(num5, 0.25f, 1.35f));
			Band(px, W, H, num2 - 0.01f, (num3 - 0.01f) / 1.5f, num2 + 0.01f, (num3 + 0.01f) / 1.5f, C(15726328u));
			int num6 = Mathf.FloorToInt(t / 7f);
			for (int k = 0; k < 3; k++)
			{
				Band(px, W, H, 0.4f - (float)k * 0.035f, 0.035f, 0.418f - (float)k * 0.035f, 0.062f, C((num6 % 4 > k) ? 12109000u : 1711652u));
				Band(px, W, H, 0.582f + (float)k * 0.035f, 0.035f, 0.6f + (float)k * 0.035f, 0.062f, C(((num6 + 2) % 4 > k) ? 12109000u : 1711652u));
			}
			void Paddle(float u, float q)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				Band(px, W, H, u - 0.009f, (q - 0.085f) / 1.5f, u + 0.009f, (q + 0.085f) / 1.5f, C(14214376u));
			}
		}

		private static void PaintSnake(Color32[] px, int W, int H, float t)
		{
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			if (snakePathX == null)
			{
				List<int> list = new List<int>();
				List<int> list2 = new List<int>();
				for (int i = 0; i < 24; i++)
				{
					if (i % 2 == 0)
					{
						for (int j = 0; j < 15; j++)
						{
							list.Add(j);
							list2.Add(i);
						}
						continue;
					}
					for (int num = 14; num >= 0; num--)
					{
						list.Add(num);
						list2.Add(i);
					}
				}
				for (int num2 = 23; num2 >= 0; num2--)
				{
					list.Add(15);
					list2.Add(num2);
				}
				snakePathX = list.ToArray();
				snakePathY = list2.ToArray();
			}
			for (int k = 0; k < H; k++)
			{
				for (int l = 0; l < W; l++)
				{
					Set(px, W, H, l, k, (l % 8 == 0 || k % 8 == 0) ? C(923149u) : C(725514u));
				}
			}
			int num3 = snakePathX.Length;
			int num4 = Mathf.FloorToInt(t * 13f) % num3;
			int num5 = (num4 + 37) % num3;
			Disc(px, W, H, ((float)(snakePathX[num5] * 8) + 4f) / (float)W, ((float)(snakePathY[num5] * 8) + 4f) / (float)H, 0.013f + 0.003f * Mathf.Sin(t * 3f), C(14698568u));
			for (int num6 = 15; num6 >= 1; num6--)
			{
				int num7 = (num4 - num6 + num3) % num3;
				CellRect(snakePathX[num7], snakePathY[num7], Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(7784526u)), Color32.op_Implicit(C(3037732u)), (float)num6 / 16f)), 1);
			}
			CellRect(snakePathX[num4], snakePathY[num4], C(13172602u), 0);
			void CellRect(int c, int r, Color32 col, int inset)
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				Band(px, W, H, (float)(c * 8 + inset) / (float)W, (float)(r * 8 + inset) / (float)H, (float)(c * 8 + 8 - inset) / (float)W, (float)(r * 8 + 8 - inset) / (float)H, col);
			}
		}

		private static void PaintBrickwall(Color32[] px, int W, int H, float t)
		{
			//IL_0064: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, (i % 3 == 0) ? C(263689u) : C(395277u));
				}
			}
			Band(px, W, H, 0f, 0f, 0.02f, 1f, C(2764342u));
			Band(px, W, H, 0.98f, 0f, 1f, 1f, C(2764342u));
			uint[] array = new uint[6] { 13123648u, 14186554u, 14205000u, 5814360u, 4761784u, 5793992u };
			float num = Mathf.Repeat(t, 26f) / 26f * 1.05f;
			for (int k = 0; k < 6; k++)
			{
				for (int l = 0; l < 9; l++)
				{
					if (!(Hash01(l, k, 4747) < num))
					{
						float num2 = 0.05f + (float)l * 0.099999994f;
						float num3 = 0.1f + (float)k * 0.042f;
						Band(px, W, H, num2 + 0.004f, num3, num2 + 0.099999994f - 0.004f, num3 + 0.034f, C(array[k]));
					}
				}
			}
			float num4 = 0.1f + 0.8f * Tri01(t * 0.83f);
			float num5 = 0.4f + 0.56f * Tri01(t * 0.57f + 0.2f);
			Band(px, W, H, num4 - 0.008f, num5 - 0.006f, num4 + 0.008f, num5 + 0.006f, C(15726328u));
			float num6 = Mathf.Clamp(0.1f + 0.8f * Tri01(t * 0.83f - 0.04f), 0.1f, 0.9f);
			Band(px, W, H, num6 - 0.06f, 0.955f, num6 + 0.06f, 0.972f, C(14214376u));
		}

		private static void AddBatch72(List<Def> t)
		{
			P("Magma Cracks", PaintMagmaCracks);
			P("Topographic", PaintTopographic);
			P("It Became a Cube", PaintCube);
			P("Geode", PaintGeode);
			P("Circuit Board", PaintCircuit);
			P("Urban Camo", delegate(Color32[] px, int W, int H)
			{
				BlockNoise(px, W, H, 2077, 10, new uint[4] { 3816770u, 5790819u, 2303274u, 7370110u });
			});
			P("Void Camo", delegate(Color32[] px, int W, int H)
			{
				BlockNoise(px, W, H, 606, 10, new uint[4] { 1970224u, 4003427u, 5974670u, 1182238u });
			});
			P("Tally Marks", PaintTally);
			P("Petrichor V", PaintPetrichor);
			P("Stained Glass", PaintStainedGlass);
			A("Hellfire", PaintHellfire, 8f);
			A("Aurora", PaintAurora, 5f);
			A("Lava Lamp", PaintLavaLamp, 11f);
			A("Plasma", PaintPlasma, 3f);
			A("Hyperspace", PaintHyperspace, 7f);
			L("Living Void", LiveSkin.Void, PaintVoidStill);
			L("Living Flame", LiveSkin.Flame, PaintFlameStill);
			void A(string name, Action<Color32[], int, int, float> anim, float still)
			{
				t.Add(new Def
				{
					name = name,
					cat = BgCat.Pattern,
					anim = anim,
					paint = delegate(Color32[] px, int W, int H)
					{
						anim(px, W, H, still);
					}
				});
			}
			void L(string name, LiveSkin live, Action<Color32[], int, int> paint)
			{
				t.Add(new Def
				{
					name = name,
					cat = BgCat.Pattern,
					live = live,
					paint = paint
				});
			}
			void P(string name, Action<Color32[], int, int> paint)
			{
				t.Add(new Def
				{
					name = name,
					cat = BgCat.Pattern,
					paint = paint
				});
			}
		}

		private static float Hash01(int x, int y, int s)
		{
			int num = (int)(x * 374761393 + y * 668265263 + s * 2246822519u);
			int num2 = (num ^ (num >>> 13)) * 1274126177;
			return (float)(uint)((num2 ^ (num2 >>> 16)) & 0xFFFFFF) / 16777216f;
		}

		private static float VNoise(float x, float y, int s)
		{
			int num = Mathf.FloorToInt(x);
			int num2 = Mathf.FloorToInt(y);
			float num3 = x - (float)num;
			float num4 = y - (float)num2;
			num3 = num3 * num3 * (3f - 2f * num3);
			num4 = num4 * num4 * (3f - 2f * num4);
			float num5 = Hash01(num, num2, s);
			float num6 = Hash01(num + 1, num2, s);
			float num7 = Hash01(num, num2 + 1, s);
			float num8 = Hash01(num + 1, num2 + 1, s);
			return Mathf.Lerp(Mathf.Lerp(num5, num6, num3), Mathf.Lerp(num7, num8, num3), num4);
		}

		private static float Fbm(float x, float y, int s, int oct)
		{
			float num = 0f;
			float num2 = 0.5f;
			for (int i = 0; i < oct; i++)
			{
				num += VNoise(x, y, s + i * 101) * num2;
				x *= 2.03f;
				y *= 2.03f;
				num2 *= 0.5f;
			}
			return num;
		}

		private static void StampLine(Color32[] px, int W, int H, float u0, float q0, float u1, float q1, float r, Color32 c, int steps)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i <= steps; i++)
			{
				float num = (float)i / (float)steps;
				Disc(px, W, H, Mathf.Lerp(u0, u1, num), Mathf.Lerp(q0, q1, num) / 1.5f, r, c);
			}
		}

		private static uint XNext(ref uint s)
		{
			s ^= s << 13;
			s ^= s >> 17;
			s ^= s << 5;
			return s;
		}

		private static void PaintMagmaCracks(Color32[] px, int W, int H)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			BlockNoise(px, W, H, 7801, 16, new uint[4] { 1643537u, 1972243u, 1380624u, 2234900u });
			Random rng = new Random(7802);
			List<Vector2> pts = new List<Vector2>();
			List<Vector2> list = new List<Vector2>();
			for (int i = 0; i < 5; i++)
			{
				float u = 0.08f + 0.84f * (float)rng.NextDouble();
				float q = 0.32999998f * (float)rng.NextDouble();
				Walk(u, q, MathF.PI / 2f, 62);
				list.Add(pts[pts.Count - rng.Next(20, 45)]);
			}
			foreach (Vector2 item in list)
			{
				Walk(item.x, item.y, MathF.PI / 2f + ((float)rng.NextDouble() - 0.5f) * 1.6f, 26);
			}
			foreach (Vector2 item2 in pts)
			{
				Disc(px, W, H, item2.x, item2.y / 1.5f, 0.02f, C(5379589u));
			}
			foreach (Vector2 item3 in pts)
			{
				Disc(px, W, H, item3.x, item3.y / 1.5f, 0.011f, C(12732175u));
			}
			foreach (Vector2 item4 in pts)
			{
				Disc(px, W, H, item4.x, item4.y / 1.5f, 0.005f, C(16757054u));
			}
			SpeckleDiscs(px, W, H, 7803, 24, 0.002f, 0.005f, new uint[2] { 16742942u, 14043666u });
			void Walk(float num, float num2, float a, int steps)
			{
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				for (int j = 0; j < steps; j++)
				{
					a += ((float)rng.NextDouble() - 0.5f) * 0.9f;
					a = Mathf.Clamp(a, 0.47079635f, 2.6707964f);
					num += Mathf.Cos(a) * 0.016f;
					num2 += Mathf.Sin(a) * 0.016f;
					pts.Add(new Vector2(num, num2));
				}
			}
		}

		private static void PaintTopographic(Color32[] px, int W, int H)
		{
			//IL_0062: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num = ((float)j + 0.5f) / (float)W;
					float num2 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num3 = Fbm(num * 2.6f, num2 * 1.8f, 5501, 3);
					float num4 = num3 * 10f;
					int num5 = Mathf.FloorToInt(num4);
					Color32 c = Color32.op_Implicit(Color.Lerp(new Color(0.059f, 0.082f, 0.11f), new Color(0.086f, 0.125f, 0.165f), num3));
					if (num4 - (float)num5 < 0.06f)
					{
						c = C((num5 % 5 == 0) ? 5227425u : 2578508u);
					}
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void PaintCube(Color32[] px, int W, int H)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0088: 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_0090: 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_009e: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00cb: 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_00df: 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_00e1: 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_00f5: 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_00f8: 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_012a: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 723728u, 1511962u);
			Vector2 a = V(0.5f, 0.52f);
			Vector2 b = V(0.73f, 0.635f);
			Vector2 val = V(0.5f, 0.75f);
			Vector2 val2 = V(0.26999998f, 0.635f);
			Vector2 val3 = V(0.73f, 0.895f);
			Vector2 val4 = V(0.5f, 1.01f);
			Vector2 c = V(0.26999998f, 0.895f);
			Tri(px, W, H, a, b, val, C(5857385u));
			Tri(px, W, H, a, val, val2, C(5857385u));
			Tri(px, W, H, val2, val, val4, C(3883080u));
			Tri(px, W, H, val2, val4, c, C(3883080u));
			Tri(px, W, H, val, b, val3, C(2501169u));
			Tri(px, W, H, val, val3, val4, C(2501169u));
			StampLine(px, W, H, 0.26999998f, 0.635f, 0.26999998f, 0.895f, 0.005f, C(14168606u), 60);
			StampLine(px, W, H, 0.73f, 0.635f, 0.73f, 0.895f, 0.005f, C(14168606u), 60);
			StampLine(px, W, H, 0.5f, 0.75f, 0.5f, 1.01f, 0.005f, C(14168606u), 60);
			StampLine(px, W, H, 0.26999998f, 0.895f, 0.5f, 1.01f, 0.004f, C(9314066u), 70);
			StampLine(px, W, H, 0.5f, 1.01f, 0.73f, 0.895f, 0.004f, C(9314066u), 70);
			Random random = new Random(5601);
			for (int i = 0; i < 14; i++)
			{
				float num = (float)(random.NextDouble() * 2.0 * 3.1415927410125732);
				float num2 = 0.3f + 0.22f * (float)random.NextDouble();
				Disc(px, W, H, 0.5f + Mathf.Cos(num) * num2, (0.765f + Mathf.Sin(num) * num2) / 1.5f, 0.003f + 0.004f * (float)random.NextDouble(), C((i % 3 == 0) ? 16734780u : 14168606u));
			}
			static Vector2 V(float u, float q)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2(u, q / 1.5f);
			}
		}

		private static void PaintGeode(Color32[] px, int W, int H)
		{
			//IL_0097: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: 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_00e7: 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_0125: 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_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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num = ((float)j + 0.5f) / (float)W;
					float num2 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num3 = num - 0.5f;
					float num4 = num2 - 0.72f;
					float num5 = Mathf.Sqrt(num3 * num3 + num4 * num4);
					float num6 = (VNoise(num * 6.5f, num2 * 6.5f, 6601) - 0.5f) * 0.13f;
					float num7 = num5 + num6 * Mathf.Clamp01(num5 * 3f);
					Color32 c = ((!(num7 < 0.115f)) ? ((!(num7 < 0.175f)) ? ((!(num7 < 0.235f)) ? ((!(num7 < 0.285f)) ? ((!(num7 < 0.33f)) ? Color32.op_Implicit(Color.Lerp(new Color(0.208f, 0.2f, 0.227f), new Color(0.255f, 0.243f, 0.275f), VNoise(num * 9f, num2 * 9f, 6602))) : C(9080213u)) : C(15131376u)) : C(10189784u)) : C(6964408u)) : C(1708070u));
					Set(px, W, H, j, i, c);
				}
			}
			Random random = new Random(6603);
			for (int k = 0; k < 90; k++)
			{
				float num8 = 0.32f + 0.36f * (float)random.NextDouble();
				float num9 = 0.54f + 0.36f * (float)random.NextDouble();
				float num10 = num8 - 0.5f;
				float num11 = num9 - 0.72f;
				if (!(num10 * num10 + num11 * num11 > 0.011024999f))
				{
					Disc(px, W, H, num8, num9 / 1.5f, 0.003f + 0.003f * (float)random.NextDouble(), C((k % 3 == 0) ? 15723258u : 12032752u));
				}
			}
		}

		private static void PaintCircuit(Color32[] px, int W, int H)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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)
			Fill(px, W, H, C(794643u));
			Random rng = new Random(6701);
			float cell = 0.0625f;
			float thU = 1.2f / (float)W * 2f;
			List<Vector2> pads = new List<Vector2>();
			for (int i = 0; i < 9; i++)
			{
				Trace(1993527u, 14);
			}
			for (int j = 0; j < 3; j++)
			{
				Trace(3121490u, 11);
			}
			foreach (Vector2 item in pads)
			{
				Disc(px, W, H, item.x, item.y / 1.5f, 0.016f, C(14201930u));
				Disc(px, W, H, item.x, item.y / 1.5f, 0.007f, C(794643u));
			}
			Chip(0.16f, 0.3f, 0.44f, 0.4f);
			Chip(0.58f, 0.62f, 0.88f, 0.74f);
			void Chip(float u0, float v0, float u1, float v1)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: 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)
				float num = 0.012f;
				for (float num2 = u0 + 0.02f; num2 < u1 - 0.015f; num2 += 0.035f)
				{
					Band(px, W, H, num2, v0 - num / 1.5f, num2 + 0.014f, v0, C(12032574u));
					Band(px, W, H, num2, v1, num2 + 0.014f, v1 + num / 1.5f, C(12032574u));
				}
				Band(px, W, H, u0, v0, u1, v1, C(1053206u));
				Band(px, W, H, u0 + 0.015f, v0 + 0.01f, u0 + 0.05f, v0 + 0.018f, C(1842982u));
			}
			void Trace(uint col, int steps)
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				int num = rng.Next(2, 15);
				int num2 = rng.Next(2, 22);
				int num3 = rng.Next(4);
				pads.Add(new Vector2(((float)num + 0.5f) * cell, ((float)num2 + 0.5f) * cell));
				for (int k = 0; k < steps; k++)
				{
					if (rng.Next(10) < 3)
					{
						num3 = (num3 + ((rng.Next(2) == 0) ? 1 : 3)) % 4;
					}
					int num4 = num + num3 switch
					{
						2 => -1, 
						0 => 1, 
						_ => 0, 
					};
					int num5 = num2 + num3 switch
					{
						3 => -1, 
						1 => 1, 
						_ => 0, 
					};
					num4 = Mathf.Clamp(num4, 1, 15);
					int num6 = Mathf.Clamp(num5, 1, 23);
					float num7 = ((float)num2 + 0.5f) * cell / 1.5f;
					float num8 = ((float)num6 + 0.5f) * cell / 1.5f;
					float num9 = ((float)num + 0.5f) * cell;
					float num10 = ((float)num4 + 0.5f) * cell;
					Band(px, W, H, Mathf.Min(num9, num10) - thU * 0.5f, Mathf.Min(num7, num8) - thU * 0.5f / 1.5f, Mathf.Max(num9, num10) + thU * 0.5f, Mathf.Max(num7, num8) + thU * 0.5f / 1.5f, C(col));
					num = num4;
					num2 = num6;
				}
				pads.Add(new Vector2(((float)num + 0.5f) * cell, ((float)num2 + 0.5f) * cell));
			}
		}

		private static void PaintTally(Color32[] px, int W, int H)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00c8: 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_00d2: 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_00e0: 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_018c: Unknown result type (might be due to invalid IL or missing references)
			BlockNoise(px, W, H, 6801, 16, new uint[4] { 2304043u, 2501422u, 2106664u, 2633008u });
			Random random = new Random(6802);
			int num = 0;
			for (int i = 0; i < 5; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					num++;
					float num2 = 0.1f + (float)j * 0.3f + ((float)random.NextDouble() - 0.5f) * 0.02f;
					float num3 = 0.08f + (float)i * 0.175f + ((float)random.NextDouble() - 0.5f) * 0.015f;
					bool flag = i == 4 && j == 2;
					int num4 = (flag ? 2 : 4);
					bool num5 = num == 11;
					Color32 c = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(C(14080722u)), Color32.op_Implicit(C(12172982u)), (float)random.NextDouble()));
					if (num5)
					{
						c = C(11022898u);
					}
					for (int k = 0; k < num4; k++)
					{
						float num6 = num2 + (float)k * 0.045f + ((float)random.NextDouble() - 0.5f) * 0.008f;
						float num7 = ((float)random.NextDouble() - 0.5f) * 0.008f;
						Band(px, W, H, num6 - 0.006f, num3 + num7, num6 + 0.006f, num3 + 0.085f + num7, c);
					}
					if (!flag)
					{
						StampLine(px, W, H, num2 - 0.025f, (num3 + 0.075f) * 1.5f, num2 + 0.16f, (num3 + 0.012f) * 1.5f, 0.006f, c, 24);
					}
				}
			}
		}

		private static void PaintPetrichor(Color32[] px, int W, int H)
		{
			//IL_0053: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 461854u, 1582654u);
			SpeckleDiscs(px, W, H, 6901, 80, 0.0015f, 0.0045f, new uint[3] { 15265528u, 10466008u, 7242412u });
			Disc(px, W, H, 0.66f, 0.2f, 0.15f, C(14278892u));
			Random random = new Random(6903);
			for (int i = 0; i < 7; i++)
			{
				float num = (float)(random.NextDouble() * 2.0 * 3.1415927410125732);
				float num2 = 0.11f * (float)random.NextDouble();
				float num3 = 0.012f + 0.02f * (float)random.NextDouble();
				float num4 = 0.66f + Mathf.Cos(num) * num2;
				float num5 = 0.3f + Mathf.Sin(num) * num2;
				Disc(px, W, H, num4, num5 / 1.5f, num3, C(11976914u));
				Disc(px, W, H, num4 - num3 * 0.2f, (num5 - num3 * 0.15f) / 1.5f, num3 * 0.6f, C(10858434u));
			}
			Disc(px, W, H, 0.775f, 0.126f, 0.05f, C(659234u));
			Disc(px, W, H, 0.8f, 0.1f, 0.013f, C(12963551u));
			Disc(px, W, H, 0.835f, 0.085f, 0.009f, C(12963551u));
			Disc(px, W, H, 0.86f, 0.115f, 0.006f, C(11582157u));
			for (int j = 0; j < W; j++)
			{
				float num6 = ((float)j + 0.5f) / (float)W;
				float num7 = 0.72f + 0.1f * Fbm(num6 * 2.9f, 0.37f, 6902, 3);
				float num8 = 0.84f + 0.08f * Fbm(num6 * 4.1f, 7.7f, 6902, 3);
				for (int k = Mathf.Max(0, Mathf.FloorToInt(num7 * (float)H)); k < H; k++)
				{
					Set(px, W, H, j, k, C(658707u));
				}
				for (int l = Mathf.Max(0, Mathf.FloorToInt(num8 * (float)H)); l < H; l++)
				{
					Set(px, W, H, j, l, C(395276u));
				}
			}
		}

		private static void PaintStainedGlass(Color32[] px, int W, int H)
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_0124: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(7001);
			float[] array = new float[22];
			float[] array2 = new float[22];
			for (int i = 0; i < 22; i++)
			{
				array[i] = (float)random.NextDouble();
				array2[i] = (float)random.NextDouble() * 1.5f;
			}
			uint[] array3 = new uint[8] { 9314616u, 1982342u, 2060360u, 12618282u, 5974670u, 1403508u, 11814944u, 4090782u };
			for (int j = 0; j < H; j++)
			{
				for (int k = 0; k < W; k++)
				{
					float num = ((float)k + 0.5f) / (float)W;
					float num2 = ((float)j + 0.5f) / (float)H * 1.5f;
					float num3 = float.MaxValue;
					float num4 = float.MaxValue;
					int num5 = 0;
					for (int l = 0; l < 22; l++)
					{
						float num6 = num - array[l];
						float num7 = num2 - array2[l];
						float num8 = Mathf.Sqrt(num6 * num6 + num7 * num7);
						if (num8 < num3)
						{
							num4 = num3;
							num3 = num8;
							num5 = l;
						}
						else if (num8 < num4)
						{
							num4 = num8;
						}
					}
					Color32 c;
					if (num4 - num3 < 0.014f)
					{
						c = C(1315352u);
					}
					else
					{
						c = C(array3[(int)((uint)(num5 * 2654435761u) >> 8) % 8]);
						c = Color32.op_Implicit(Color.Lerp(Color32.op_Implicit(c), Color.white, Mathf.Clamp01(1f - num3 * 3.2f) * 0.22f));
					}
					Set(px, W, H, k, j, c);
				}
			}
		}

		private static void PaintHellfire(Color32[] px, int W, int H, float t)
		{
			//IL_0157: 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_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			if (fireLut == null)
			{
				fireLut = (Color32[])(object)new Color32[256];
				for (int i = 0; i < 256; i++)
				{
					float num = (float)i / 255f;
					Color val = ((num < 0.25f) ? Color.Lerp(new Color(0.027f, 0.02f, 0.02f), new Color(0.184f, 0.059f, 0.027f), num / 0.25f) : ((num < 0.5f) ? Color.Lerp(new Color(0.184f, 0.059f, 0.027f), new Color(0.557f, 0.173f, 0.043f), (num - 0.25f) / 0.25f) : ((num < 0.7f) ? Color.Lerp(new Color(0.557f, 0.173f, 0.043f), new Color(0.839f, 0.353f, 0.094f), (num - 0.5f) / 0.2f) : ((num < 0.88f) ? Color.Lerp(new Color(0.839f, 0.353f, 0.094f), new Color(1f, 0.639f, 0.18f), (num - 0.7f) / 0.18f) : Color.Lerp(new Color(1f, 0.639f, 0.18f), new Color(1f, 0.914f, 0.604f), (num - 0.88f) / 0.12f)))));
					fireLut[i] = Color32.op_Implicit(val);
				}
			}
			int num2 = W * H;
			if (fireHeat == null || fireHeat.Length != num2 || t < fireLastT - 0.5f || t - fireLastT > 6f)
			{
				fireHeat = new byte[num2];
				fireRng = 2654435769u;
				for (int j = 0; j < W; j++)
				{
					fireHeat[j] = byte.MaxValue;
				}
				fireLastT = t - 1.3333334f;
			}
			int num3 = Mathf.Clamp((int)((t - fireLastT) * 30f), 0, 40);
			if (num3 > 0)
			{
				fireLastT = t;
			}
			for (int k = 0; k < num3; k++)
			{
				for (int l = 0; l < W; l++)
				{
					fireHeat[l] = (byte)(230 + (XNext(ref fireRng) & 0xF));
				}
				for (int num4 = H - 1; num4 >= 1; num4--)
				{
					int num5 = num4 * W;
					int num6 = num5 - W;
					for (int m = 0; m < W; m++)
					{
						int num7 = fireHeat[num6 + m];
						if (num7 == 0)
						{
							fireHeat[num5 + m] = 0;
							continue;
						}
						uint num8 = XNext(ref fireRng);
						int num9 = (int)((num8 >> 4) % 3 - 1);
						int num10 = Mathf.Clamp(m + num9, 0, W - 1);
						int num11 = (int)(num8 & 0xF);
						int num12 = ((num11 >= 8) ? ((num11 < 12) ? 2 : ((num11 < 14) ? 5 : 12)) : 0);
						int num13 = num7 - num12;
						fireHeat[num5 + num10] = (byte)((num13 >= 0) ? ((uint)num13) : 0u);
					}
				}
			}
			for (int n = 0; n < num2; n++)
			{
				px[n] = fireLut[fireHeat[n]];
			}
		}

		private static void PaintAurora(Color32[] px, int W, int H, float t)
		{
			//IL_01b1: 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_01da: 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_0268: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 330262u, 725542u);
			SpeckleDiscs(px, W, H, 8101, 70, 0.002f, 0.005f, new uint[2] { 13227240u, 9413572u });
			for (int i = 0; i < H; i++)
			{
				float num = ((float)i + 0.5f) / (float)H * 1.5f;
				int num2 = (H - 1 - i) * W;
				for (int j = 0; j < W; j++)
				{
					float num3 = ((float)j + 0.5f) / (float)W;
					float num4 = 0.42f + 0.1f * Mathf.Sin(num3 * 3.1f + t * 0.23f) + 0.05f * Mathf.Sin(num3 * 6.7f - t * 0.31f);
					float num5 = 0.62f + 0.12f * Mathf.Sin(num3 * 2.3f - t * 0.17f + 1.7f) + 0.04f * Mathf.Sin(num3 * 8.1f + t * 0.41f);
					float num6 = 0.3f + 0.08f * Mathf.Sin(num3 * 4.3f + t * 0.13f + 3.4f);
					float num7 = Mathf.Max(0f, 1f - Mathf.Abs(num - num4) / 0.16f);
					float num8 = Mathf.Max(0f, 1f - Mathf.Abs(num - num5) / 0.13f);
					float num9 = Mathf.Max(0f, 1f - Mathf.Abs(num - num6) / 0.1f);
					num7 *= num7;
					num8 *= num8;
					num9 *= num9;
					if (!(num7 + num8 + num9 <= 0.001f))
					{
						Color32 val = px[num2 + j];
						int num10 = val.r + (int)(num7 * 18f + num8 * 12f + num9 * 74f);
						int num11 = val.g + (int)(num7 * 148f + num8 * 118f + num9 * 30f);
						int num12 = val.b + (int)(num7 * 74f + num8 * 122f + num9 * 156f);
						px[num2 + j] = new Color32((byte)((num10 > 255) ? 255u : ((uint)num10)), (byte)((num11 > 255) ? 255u : ((uint)num11)), (byte)((num12 > 255) ? 255u : ((uint)num12)), byte.MaxValue);
					}
				}
			}
		}

		private static void PaintLavaLamp(Color32[] px, int W, int H, float t)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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_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_01f1: Unknown result type (might be due to invalid IL or missing references)
			float[] array = lavaBu;
			float[] array2 = lavaBq;
			float[] array3 = lavaBr2;
			for (int i = 0; i < 6; i++)
			{
				array[i] = 0.5f + 0.3f * Mathf.Sin(t * lavaS1[i] * 2f * MathF.PI + lavaP1[i]);
				array2[i] = 0.75f + 0.6f * Mathf.Sin(t * lavaS2[i] * 2f * MathF.PI + lavaP2[i]);
				array3[i] = lavaR[i] * lavaR[i];
			}
			for (int j = 0; j < H; j++)
			{
				float num = ((float)j + 0.5f) / (float)H * 1.5f;
				for (int k = 0; k < W; k++)
				{
					float num2 = ((float)k + 0.5f) / (float)W;
					float num3 = 0f;
					for (int l = 0; l < 6; l++)
					{
						float num4 = num2 - array[l];
						float num5 = num - array2[l];
						num3 += array3[l] / (num4 * num4 + num5 * num5 + 0.0001f);
					}
					Color32 c = ((!(num3 > 1f)) ? ((!(num3 > 0.7f)) ? Color32.op_Implicit(Color.Lerp(new Color(0.125f, 0.063f, 0.141f), new Color(0.18f, 0.082f, 0.071f), ((float)j + 0.5f) / (float)H)) : Color32.op_Implicit(Color.Lerp(new Color(0.173f, 0.078f, 0.098f), new Color(0.69f, 0.227f, 0.086f), (num3 - 0.7f) / 0.3f))) : Color32.op_Implicit(Color.Lerp(new Color(0.91f, 0.392f, 0.118f), new Color(1f, 0.808f, 0.345f), Mathf.Clamp01((num3 - 1f) * 0.9f))));
					Set(px, W, H, k, j, c);
				}
			}
		}

		private static void PaintPlasma(Color32[] px, int W, int H, float t)
		{
			//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_014a: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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)
			float num = 0.5f + 0.25f * Mathf.Sin(t * 0.37f);
			float num2 = 0.75f + 0.35f * Mathf.Cos(t * 0.29f);
			Color val = default(Color);
			((Color)(ref val))..ctor(0.071f, 0.039f, 0.149f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.357f, 0.165f, 0.557f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.91f, 0.478f, 0.188f);
			for (int i = 0; i < H; i++)
			{
				float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
				for (int j = 0; j < W; j++)
				{
					float num4 = ((float)j + 0.5f) / (float)W;
					float num5 = Mathf.Sin(num4 * 5.9f + t * 0.63f);
					float num6 = Mathf.Sin(num4 * 2.7f - num3 * 3.4f - t * 0.85f);
					float num7 = num4 - num;
					float num8 = num3 - num2;
					float num9 = Mathf.Sin(Mathf.Sqrt(num7 * num7 + num8 * num8) * 11f - t * 1.35f);
					float num10 = ((num5 + num6 + num9) / 3f + 1f) * 0.5f;
					Color32 c = Color32.op_Implicit((num10 < 0.5f) ? Color.Lerp(val, val2, num10 * 2f) : Color.Lerp(val2, val3, (num10 - 0.5f) * 2f));
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void PaintHyperspace(Color32[] px, int W, int H, float t)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_011f: 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_0186: Unknown result type (might be due to invalid IL or missing references)
			Fill(px, W, H, C(263693u));
			SpeckleDiscs(px, W, H, 7207, 110, 0.0015f, 0.004f, new uint[2] { 3820142u, 6058400u });
			for (int i = 0; i < 130; i++)
			{
				uint num = (uint)(i * 2654435761u);
				num ^= num >> 15;
				num *= 2246822519u;
				num ^= num >> 13;
				float num2 = (float)(num & 0xFFF) / 4096f * 2f * MathF.PI;
				float num3 = 0.35f + 0.5f * ((float)((num >> 12) & 0x3FF) / 1024f);
				float num4 = (float)((num >> 22) & 0x3FF) / 1024f;
				float num5 = Mathf.Repeat(t * num3 * 0.25f + num4, 1f);
				float num6 = num5 * num5 * 1.35f + 0.02f;
				float num7 = 0.05f + 0.16f * num5;
				float num8 = Mathf.Cos(num2);
				float num9 = Mathf.Sin(num2);
				Color32 c = Color32.op_Implicit(Color.Lerp(new Color(0.325f, 0.439f, 0.624f), Color.white, num5));
				float num10 = 0.005f + 0.005f * num5;
				for (int j = 0; j <= 6; j++)
				{
					float num11 = num6 - num7 * ((float)j / 6f);
					if (!(num11 <= 0f))
					{
						Disc(px, W, H, 0.5f + num8 * num11, (1.08f + num9 * num11) / 1.5f, num10 * (1f - 0.09f * (float)j), c);
					}
				}
			}
		}

		private static void PaintVoidStill(Color32[] px, int W, int H)
		{
			//IL_0050: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 722708u, 1838896u);
			Random random = new Random(7101);
			for (int i = 0; i < 8; i++)
			{
				Disc(px, W, H, (float)random.NextDouble(), (float)random.NextDouble() * 0.7f, 0.1f + 0.1f * (float)random.NextDouble(), C(1444646u));
			}
			for (int j = 0; j < 5; j++)
			{
				Disc(px, W, H, (float)random.NextDouble(), 0.2f + (float)random.NextDouble() * 0.6f, 0.05f + 0.07f * (float)random.NextDouble(), C(2364228u));
			}
			Ring(px, W, H, 0.5f, 0.42f, 0.16f, 0.02f, C(4003427u));
			SpeckleDiscs(px, W, H, 7102, 20, 0.002f, 0.007f, new uint[3] { 10247167u, 13214463u, 7224256u });
		}

		private static void PaintFlameStill(Color32[] px, int W, int H)
		{
			//IL_007f: 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_009a: 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_00bd: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			VGrad(px, W, H, 722437u, 3411976u);
			Random random = new Random(7201);
			for (int i = 0; i < 7; i++)
			{
				float num = 0.08f + (float)i * 0.13f + ((float)random.NextDouble() - 0.5f) * 0.04f;
				float num2 = ((float)random.NextDouble() - 0.5f) * 0.1f;
				float num3 = 0.78f - (float)random.NextDouble() * 0.2f;
				Tri(px, W, H, new Vector2(num - 0.055f, 1.02f), new Vector2(num + 0.055f, 1.02f), new Vector2(num + num2, num3), C(14045978u));
				Tri(px, W, H, new Vector2(num - 0.03f, 1.02f), new Vector2(num + 0.03f, 1.02f), new Vector2(num + num2 * 0.8f, num3 + 0.06f), C(16753454u));
				if (i % 3 == 0)
				{
					Tri(px, W, H, new Vector2(num - 0.014f, 1.02f), new Vector2(num + 0.014f, 1.02f), new Vector2(num + num2 * 0.6f, num3 + 0.13f), C(16769674u));
				}
			}
			SpeckleDiscs(px, W, H, 7202, 26, 0.002f, 0.005f, new uint[3] { 16751164u, 16738816u, 14043666u });
		}

		public static bool IsFree(int idx)
		{
			if (idx >= 0 && idx < Table.Length)
			{
				return Table[idx].cat != BgCat.Pattern;
			}
			return false;
		}

		public static bool IsOwned(string profileKey, int idx)
		{
			if (idx < 0 || idx >= Table.Length)
			{
				return false;
			}
			if (IsFree(idx))
			{
				return true;
			}
			IReadOnlyList<int> readOnlyList = UserLifetimeStats.UnlockedBackgrounds(profileKey);
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				if (readOnlyList[i] == idx)
				{
					return true;
				}
			}
			return false;
		}

		public static int CurrentBackground(NetworkUser nu)
		{
			return CurrentForProfile(UserLifetimeStats.ProfileKey(nu));
		}

		public static int CurrentForProfile(string key)
		{
			if (key == null)
			{
				return 0;
			}
			int chosenBackground = UserLifetimeStats.GetChosenBackground(key);
			return UserLifetimeStats.WornCosmetic(chosenBackground, IsOwned(key, chosenBackground), UserLifetimeStats.UnlockedBackgrounds(key), 0);
		}

		public static int QueueRandomPattern(NetworkUser nu, Random rng)
		{
			string key = UserLifetimeStats.ProfileKey(nu);
			if (key == null)
			{
				return -1;
			}
			int num = UserLifetimeStats.DrawLockedIndex(rng, Table.Length, (int i) => IsOwned(key, i) || UserLifetimeStats.PendingContains(key, 1, i));
			if (num < 0)
			{
				return -1;
			}
			UserLifetimeStats.EnqueuePending(key, 1, num);
			return num;
		}

		public static int PatternCount()
		{
			int num = 0;
			Def[] table = Table;
			for (int i = 0; i < table.Length; i++)
			{
				if (table[i].cat == BgCat.Pattern)
				{
					num++;
				}
			}
			return num;
		}

		public static Texture2D GetTexture(int idx)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			if (idx <= 0 || idx >= Table.Length)
			{
				return null;
			}
			if (cache.TryGetValue(idx, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			bool flag = Table[idx].anim != null;
			Color32[] array = (Color32[])(object)new Color32[24576];
			Table[idx].paint(array, 128, 192);
			value = new Texture2D(128, 192, (TextureFormat)4, false);
			((Texture)value).wrapMode = (TextureWrapMode)1;
			((Texture)value).filterMode = (FilterMode)1;
			value.SetPixels32(array);
			value.Apply(false, !flag);
			cache[idx] = value;
			return value;
		}

		public static void MarkAnimatedVisible(int idx)
		{
			if (idx > 0 && idx < Table.Length && Table[idx].anim != null)
			{
				animVisible.Add(idx);
			}
		}

		public static void TickAnimated(float now)
		{
			if (animVisible.Count == 0 || now == lastAnimAt)
			{
				return;
			}
			lastAnimAt = now;
			if (animScratch == null)
			{
				animScratch = (Color32[])(object)new Color32[24576];
			}
			foreach (int item in animVisible)
			{
				if (cache.TryGetValue(item, out var value) && !((Object)(object)value == (Object)null))
				{
					Table[item].anim(animScratch, 128, 192, now);
					value.SetPixels32(animScratch);
					value.Apply(false, false);
				}
			}
			animVisible.Clear();
		}

		private static Color32 C(uint rgb)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return new Color32((byte)(rgb >> 16), (byte)(rgb >> 8), (byte)rgb, byte.MaxValue);
		}

		private static void Set(Color32[] px, int W, int H, int x, int yTop, Color32 c)
		{
			//IL_000b: 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)
			px[(H - 1 - yTop) * W + x] = c;
		}

		private static void Fill(Color32[] px, int W, int H, Color32 c)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < px.Length; i++)
			{
				px[i] = c;
			}
		}

		private static void HStripesW(Color32[] px, int W, int H, uint[] cols, float[] w)
		{
			//IL_0036: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			foreach (float num2 in w)
			{
				num += num2;
			}
			Color32[] array = (Color32[])(object)new Color32[cols.Length];
			for (int j = 0; j < cols.Length; j++)
			{
				array[j] = C(cols[j]);
			}
			for (int k = 0; k < H; k++)
			{
				float num3 = ((float)k + 0.5f) / (float)H * num;
				int num4 = 0;
				for (float num5 = w[0]; num3 > num5; num5 += w[++num4])
				{
					if (num4 >= cols.Length - 1)
					{
						break;
					}
				}
				for (int l = 0; l < W; l++)
				{
					Set(px, W, H, l, k, array[num4]);
				}
			}
		}

		private static void HStripes(Color32[] px, int W, int H, params uint[] cols)
		{
			float[] array = new float[cols.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = 1f;
			}
			HStripesW(px, W, H, cols, array);
		}

		private static void VStripesW(Color32[] px, int W, int H, uint[] cols, float[] w)
		{
			//IL_0036: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			foreach (float num2 in w)
			{
				num += num2;
			}
			Color32[] array = (Color32[])(object)new Color32[cols.Length];
			for (int j = 0; j < cols.Length; j++)
			{
				array[j] = C(cols[j]);
			}
			for (int k = 0; k < W; k++)
			{
				float num3 = ((float)k + 0.5f) / (float)W * num;
				int num4 = 0;
				for (float num5 = w[0]; num3 > num5; num5 += w[++num4])
				{
					if (num4 >= cols.Length - 1)
					{
						break;
					}
				}
				for (int l = 0; l < H; l++)
				{
					Set(px, W, H, k, l, array[num4]);
				}
			}
		}

		private static void VStripes(Color32[] px, int W, int H, params uint[] cols)
		{
			float[] array = new float[cols.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = 1f;
			}
			VStripesW(px, W, H, cols, array);
		}

		private static void Band(Color32[] px, int W, int H, float u0, float v0, float u1, float v1, Color32 c)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, Mathf.FloorToInt(u0 * (float)W));
			int num2 = Mathf.Min(W, Mathf.CeilToInt(u1 * (float)W));
			int num3 = Mathf.Max(0, Mathf.FloorToInt(v0 * (float)H));
			int num4 = Mathf.Min(H, Mathf.CeilToInt(v1 * (float)H));
			for (int i = num3; i < num4; i++)
			{
				for (int j = num; j < num2; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void Disc(Color32[] px, int W, int H, float cu, float cv, float r, Color32 c)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			int num2 = Mathf.Max(0, Mathf.FloorToInt((cu - r) * (float)W));
			int num3 = Mathf.Min(W, Mathf.CeilToInt((cu + r) * (float)W));
			int num4 = Mathf.Max(0, Mathf.FloorToInt((num - r) / 1.5f * (float)H));
			int num5 = Mathf.Min(H, Mathf.CeilToInt((num + r) / 1.5f * (float)H));
			for (int i = num4; i < num5; i++)
			{
				for (int j = num2; j < num3; j++)
				{
					float num6 = ((float)j + 0.5f) / (float)W;
					float num7 = ((float)i + 0.5f) / (float)H * 1.5f;
					if ((num6 - cu) * (num6 - cu) + (num7 - num) * (num7 - num) <= r * r)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Ring(Color32[] px, int W, int H, float cu, float cv, float r, float t, Color32 c)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			int num2 = Mathf.Max(0, Mathf.FloorToInt((cu - r) * (float)W));
			int num3 = Mathf.Min(W, Mathf.CeilToInt((cu + r) * (float)W));
			int num4 = Mathf.Max(0, Mathf.FloorToInt((num - r) / 1.5f * (float)H));
			int num5 = Mathf.Min(H, Mathf.CeilToInt((num + r) / 1.5f * (float)H));
			for (int i = num4; i < num5; i++)
			{
				for (int j = num2; j < num3; j++)
				{
					float num6 = ((float)j + 0.5f) / (float)W;
					float num7 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num8 = Mathf.Sqrt((num6 - cu) * (num6 - cu) + (num7 - num) * (num7 - num));
					if (num8 <= r && num8 >= r - t)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Crescent(Color32[] px, int W, int H, float cu, float cv, float r, float cutDu, float cutR, Color32 c)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			int num2 = Mathf.Max(0, Mathf.FloorToInt((cu - r) * (float)W));
			int num3 = Mathf.Min(W, Mathf.CeilToInt((cu + r) * (float)W));
			int num4 = Mathf.Max(0, Mathf.FloorToInt((num - r) / 1.5f * (float)H));
			int num5 = Mathf.Min(H, Mathf.CeilToInt((num + r) / 1.5f * (float)H));
			for (int i = num4; i < num5; i++)
			{
				for (int j = num2; j < num3; j++)
				{
					float num6 = ((float)j + 0.5f) / (float)W;
					float num7 = ((float)i + 0.5f) / (float)H * 1.5f;
					bool num8 = (num6 - cu) * (num6 - cu) + (num7 - num) * (num7 - num) <= r * r;
					float num9 = num6 - (cu + cutDu);
					bool flag = num9 * num9 + (num7 - num) * (num7 - num) <= cutR * cutR;
					if (num8 && !flag)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Star(Color32[] px, int W, int H, float cu, float cv, float r, float rot, Color32 c)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			float num = cv * 1.5f;
			Vector2[] array = (Vector2[])(object)new Vector2[10];
			for (int i = 0; i < 10; i++)
			{
				float num2 = ((i % 2 == 0) ? r : (r * 0.42f));
				float num3 = (-90f + rot + (float)i * 36f) * (MathF.PI / 180f);
				array[i] = new Vector2(cu + num2 * Mathf.Cos(num3), num + num2 * Mathf.Sin(num3));
			}
			int num4 = Mathf.Max(0, Mathf.FloorToInt((cu - r) * (float)W));
			int num5 = Mathf.Min(W, Mathf.CeilToInt((cu + r) * (float)W));
			int num6 = Mathf.Max(0, Mathf.FloorToInt((num - r) / 1.5f * (float)H));
			int num7 = Mathf.Min(H, Mathf.CeilToInt((num + r) / 1.5f * (float)H));
			Vector2 p = default(Vector2);
			for (int j = num6; j < num7; j++)
			{
				for (int k = num4; k < num5; k++)
				{
					((Vector2)(ref p))..ctor(((float)k + 0.5f) / (float)W, ((float)j + 0.5f) / (float)H * 1.5f);
					if (InPoly(array, p))
					{
						Set(px, W, H, k, j, c);
					}
				}
			}
		}

		private static bool InPoly(Vector2[] poly, Vector2 p)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			int num = 0;
			int num2 = poly.Length - 1;
			while (num < poly.Length)
			{
				if (poly[num].y > p.y != poly[num2].y > p.y && p.x < (poly[num2].x - poly[num].x) * (p.y - poly[num].y) / (poly[num2].y - poly[num].y) + poly[num].x)
				{
					flag = !flag;
				}
				num2 = num++;
			}
			return flag;
		}

		private static void Tri(Color32[] px, int W, int H, Vector2 a, Vector2 b, Vector2 c3, Color32 c)
		{
			//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)
			//IL_000d: 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_0025: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Min(a.x, Mathf.Min(b.x, c3.x));
			float num2 = Mathf.Max(a.x, Mathf.Max(b.x, c3.x));
			float num3 = Mathf.Min(a.y, Mathf.Min(b.y, c3.y));
			float num4 = Mathf.Max(a.y, Mathf.Max(b.y, c3.y));
			int num5 = Mathf.Max(0, Mathf.FloorToInt(num * (float)W));
			int num6 = Mathf.Min(W, Mathf.CeilToInt(num2 * (float)W));
			int num7 = Mathf.Max(0, Mathf.FloorToInt(num3 * (float)H));
			int num8 = Mathf.Min(H, Mathf.CeilToInt(num4 * (float)H));
			for (int i = num7; i < num8; i++)
			{
				for (int j = num5; j < num6; j++)
				{
					Vector2 p = new Vector2(((float)j + 0.5f) / (float)W, ((float)i + 0.5f) / (float)H);
					float num9 = Sign(p, a, b);
					float num10 = Sign(p, b, c3);
					float num11 = Sign(p, c3, a);
					bool flag = num9 < 0f || num10 < 0f || num11 < 0f;
					bool flag2 = num9 > 0f || num10 > 0f || num11 > 0f;
					if (!(flag && flag2))
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
			static float Sign(Vector2 val, Vector2 q, Vector2 s)
			{
				//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)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: 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_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: 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 (val.x - s.x) * (q.y - s.y) - (q.x - s.x) * (val.y - s.y);
			}
		}

		private static void NordicCross(Color32[] px, int W, int H, float t, Color32 c)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Band(px, W, H, 0.38f - t * 0.5f, 0f, 0.38f + t * 0.5f, 1f, c);
			Band(px, W, H, 0f, 0.5f - t * 0.5f / 1.5f, 1f, 0.5f + t * 0.5f / 1.5f, c);
		}

		private static void DiagStripes(Color32[] px, int W, int H, int periodPx, Color32 a, Color32 b)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, ((j + i) / periodPx % 2 == 0) ? a : b);
				}
			}
		}

		private static void Checker(Color32[] px, int W, int H, int cols, Color32 a, Color32 b)
		{
			//IL_0020: 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)
			int num = W / cols;
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, ((j / num + i / num) % 2 == 0) ? a : b);
				}
			}
		}

		private static void BlockNoise(Color32[] px, int W, int H, int seed, int cols, uint[] palette)
		{
			//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)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(seed);
			int num = W / cols;
			int num2 = H / num + 1;
			Color32[] array = (Color32[])(object)new Color32[palette.Length];
			for (int i = 0; i < palette.Length; i++)
			{
				array[i] = C(palette[i]);
			}
			Color32[,] array2 = new Color32[cols + 1, num2 + 1];
			for (int j = 0; j <= num2; j++)
			{
				for (int k = 0; k <= cols; k++)
				{
					array2[k, j] = array[random.Next(array.Length)];
				}
			}
			for (int l = 0; l < H; l++)
			{
				for (int m = 0; m < W; m++)
				{
					Set(px, W, H, m, l, array2[Mathf.Min(m / num, cols), Mathf.Min(l / num, num2)]);
				}
			}
		}

		private static void SpeckleDiscs(Color32[] px, int W, int H, int seed, int count, float rMin, float rMax, uint[] palette)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(seed);
			for (int i = 0; i < count; i++)
			{
				float cu = (float)random.NextDouble();
				float cv = (float)random.NextDouble();
				float r = Mathf.Lerp(rMin, rMax, (float)random.NextDouble());
				Disc(px, W, H, cu, cv, r, C(palette[random.Next(palette.Length)]));
			}
		}

		private static void VGrad(Color32[] px, int W, int H, uint top, uint bottom)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//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_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)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//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_0040: Unknown result type (might be due to invalid IL or missing references)
			Color val = Color32.op_Implicit(C(top));
			Color val2 = Color32.op_Implicit(C(bottom));
			for (int i = 0; i < H; i++)
			{
				Color32 c = Color32.op_Implicit(Color.Lerp(val, val2, ((float)i + 0.5f) / (float)H));
				for (int j = 0; j < W; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void DotGrid(Color32[] px, int W, int H, int nx, float r, Color32 c)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			float num = 1f / (float)nx;
			int num2 = Mathf.RoundToInt(1.5f / num);
			for (int i = 0; i <= num2; i++)
			{
				for (int j = 0; j <= nx; j++)
				{
					float num3 = ((i % 2 == 0) ? 0f : (num * 0.5f));
					Disc(px, W, H, (float)j * num + num3, (float)i * num / 1.5f, r, c);
				}
			}
		}

		private static void Splat(Color32[] px, int W, int H, float cu, float cv, float r, int seed, uint core, uint dark, uint bright)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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)
			Random random = new Random(seed);
			float num = cv * 1.5f;
			Disc(px, W, H, cu, cv, r * 0.72f, C(core));
			for (int i = 0; i < 8; i++)
			{
				float num2 = (float)(random.NextDouble() * 2.0 * 3.1415927410125732);
				float num3 = r * (0.3f + 0.45f * (float)random.NextDouble());
				float r2 = r * (0.28f + 0.3f * (float)random.NextDouble());
				Disc(px, W, H, cu + Mathf.Cos(num2) * num3, (num + Mathf.Sin(num2) * num3) / 1.5f, r2, C((i % 3 == 0) ? dark : core));
			}
			for (int j = 0; j < 30; j++)
			{
				float num4 = (float)(random.NextDouble() * 2.0 * 3.1415927410125732);
				float num5 = r * (0.9f + 2.4f * (float)random.NextDouble());
				float r3 = Mathf.Lerp(r * 0.16f, r * 0.045f, Mathf.InverseLerp(r * 0.9f, r * 3.3f, num5));
				Disc(px, W, H, cu + Mathf.Cos(num4) * num5, (num + Mathf.Sin(num4) * num5) / 1.5f, r3, C((j % 4 == 0) ? bright : core));
			}
		}

		private static void Drips(Color32[] px, int W, int H, int seed, float band, uint colA, uint colB)
		{
			//IL_001d: 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_0096: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(seed);
			Band(px, W, H, 0f, 0f, 1f, band, C(colA));
			for (int i = 0; i < 8; i++)
			{
				float num = ((float)i + 0.5f) / 8f + ((float)random.NextDouble() - 0.5f) * 0.07f;
				float num2 = band + 0.06f + 0.5f * (float)random.NextDouble() * (float)random.NextDouble();
				float num3 = 0.02f + 0.022f * (float)random.NextDouble();
				Color32 c = C((i % 3 == 2) ? colB : colA);
				Band(px, W, H, num - num3 * 0.5f, 0f, num + num3 * 0.5f, num2, c);
				Disc(px, W, H, num, num2, num3 * 0.85f, c);
			}
		}

		private static void UnionJack(Color32[] px, int W, int H)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_0161: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			Fill(px, W, H, C(74089u));
			float num = Mathf.Sqrt(3.25f);
			for (int i = 0; i < H; i++)
			{
				for (int j = 0; j < W; j++)
				{
					float num2 = ((float)j + 0.5f) / (float)W;
					float num3 = ((float)i + 0.5f) / (float)H * 1.5f;
					float num4 = Mathf.Abs(num2 * 1.5f - num3) / num;
					float num5 = Mathf.Abs(1.5f - num2 * 1.5f - num3) / num;
					if (num4 < 0.1f || num5 < 0.1f)
					{
						Set(px, W, H, j, i, Color32.op_Implicit(Color.white));
					}
					if (num4 < 0.045f || num5 < 0.045f)
					{
						Set(px, W, H, j, i, C(13111342u));
					}
				}
			}
			Band(px, W, H, 0.345f, 0f, 0.655f, 1f, Color32.op_Implicit(Color.white));
			Band(px, W, H, 0f, 0.39666668f, 1f, 0.60333335f, Color32.op_Implicit(Color.white));
			Band(px, W, H, 0.41f, 0f, 0.59000003f, 1f, C(13111342u));
			Band(px, W, H, 0f, 0.44f, 1f, 0.56f, C(13111342u));
		}

		private static Def[] BuildTable()
		{
			List<Def> t = new List<Def>();
			P("Plain", BgCat.Plain, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1250072u));
			});
			P("Hazard Stripes", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				DiagStripes(px, W, H, 22, C(15235584u), C(1710618u));
			});
			P("Voxel Grid", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1316380u));
				for (int i = 0; i < H; i++)
				{
					for (int j = 0; j < W; j++)
					{
						if (j % 16 == 0 || i % 16 == 0)
						{
							Set(px, W, H, j, i, C(2764346u));
						}
					}
				}
				Random random = new Random(4242);
				for (int k = 0; k < 9; k++)
				{
					int num = random.Next(W / 16);
					int num2 = random.Next(H / 16);
					Band(px, W, H, (float)num * 16f / (float)W, (float)num2 * 16f / (float)H, ((float)num * 16f + 15f) / (float)W, ((float)num2 * 16f + 15f) / (float)H, (k % 3 == 0) ? C(11754258u) : C(4008472u));
				}
			});
			P("Forest Camo", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				BlockNoise(px, W, H, 1337, 10, new uint[4] { 3885615u, 5727805u, 2765603u, 7240530u });
			});
			P("Desert Camo", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				BlockNoise(px, W, H, 7331, 10, new uint[4] { 12759680u, 10914404u, 9074001u, 14076323u });
			});
			P("Ember Field", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1511951u));
				SpeckleDiscs(px, W, H, 99, 90, 0.004f, 0.016f, new uint[4] { 16738816u, 16756736u, 12729122u, 5579281u });
			});
			P("Gold Vein", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(2365970u));
				SpeckleDiscs(px, W, H, 512, 120, 0.003f, 0.01f, new uint[3] { 16763187u, 12092939u, 3812380u });
				SpeckleDiscs(px, W, H, 513, 8, 0.014f, 0.024f, new uint[1] { 16763187u });
			});
			P("Starfield", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(658452u));
				SpeckleDiscs(px, W, H, 2001, 110, 0.002f, 0.007f, new uint[3] { 16777215u, 12571903u, 8952251u });
				SpeckleDiscs(px, W, H, 2002, 6, 0.01f, 0.015f, new uint[1] { 16777215u });
			});
			P("Boiler Plate", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(3817284u));
				DotGrid(px, W, H, 6, 0.018f, C(2303530u));
			});
			P("Banana Peel", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16768830u));
				SpeckleDiscs(px, W, H, 777, 26, 0.008f, 0.03f, new uint[3] { 8016416u, 10251046u, 6044950u });
			});
			P("Bubblegum", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16751297u));
				DotGrid(px, W, H, 5, 0.035f, C(16769518u));
			});
			P("Sunset", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				VGrad(px, W, H, 16747586u, 6106764u);
			});
			P("The Abyss", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				VGrad(px, W, H, 1347995u, 399936u);
			});
			P("Checkerboard", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				Checker(px, W, H, 6, C(2303275u), C(3816774u));
			});
			P("Moonscape", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(7238008u));
				Random random = new Random(31415);
				for (int i = 0; i < 14; i++)
				{
					float num = (float)random.NextDouble();
					float num2 = (float)random.NextDouble();
					float num3 = Mathf.Lerp(0.02f, 0.09f, (float)random.NextDouble());
					Disc(px, W, H, num, num2, num3, C(5593183u));
					Disc(px, W, H, num - num3 * 0.15f, num2 - num3 * 0.1f, num3 * 0.72f, C(4737874u));
				}
			});
			P("Rainbow Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 14942979u, 16747520u, 16772352u, 32806u, 2375822u, 7547266u);
			});
			P("Progress Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: 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_00c2: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: 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_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 14942979u, 16747520u, 16772352u, 32806u, 2375822u, 7547266u);
				Tri(px, W, H, new Vector2(0f, -0.1f), new Vector2(0.62f, 0.5f), new Vector2(0f, 1.1f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, new Vector2(0f, 0.02f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0.98f), C(16230584u));
				Tri(px, W, H, new Vector2(0f, 0.14f), new Vector2(0.38f, 0.5f), new Vector2(0f, 0.86f), C(5623292u));
				Tri(px, W, H, new Vector2(0f, 0.26f), new Vector2(0.26f, 0.5f), new Vector2(0f, 0.74f), C(9721110u));
				Tri(px, W, H, new Vector2(0f, 0.38f), new Vector2(0.14f, 0.5f), new Vector2(0f, 0.62f), C(1052688u));
			});
			P("Trans Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 5623292u, 16230584u, 16777215u, 16230584u, 5623292u);
			});
			P("Bi Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[3] { 14025328u, 10178454u, 14504u }, new float[3] { 2f, 1f, 2f });
			});
			P("Pan Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16720268u, 16766976u, 2208255u);
			});
			P("Nonbinary Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16577588u, 16777215u, 10246609u, 2894892u);
			});
			P("Lesbian Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13970688u, 16751190u, 16777215u, 13853348u, 10682978u);
			});
			P("Gay Men Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 494960u, 2543274u, 16777215u, 8105442u, 4004472u);
			});
			P("Ace Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 1052688u, 10724259u, 16777215u, 8388736u);
			});
			P("Aro Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 4040002u, 10998649u, 16777215u, 11119017u, 1052688u);
			});
			P("Genderfluid Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16741794u, 16777215u, 12458198u, 1052688u, 3358397u);
			});
			P("Genderqueer Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 11894492u, 16777215u, 4882723u);
			});
			P("Agender Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 1052688u, 12171705u, 16777215u, 12121219u, 16777215u, 12171705u, 1052688u);
			});
			P("Intersex Pride", BgCat.Pride, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				Fill(px, W, H, C(16766976u));
				Ring(px, W, H, 0.5f, 0.5f, 0.2f, 0.055f, C(7930538u));
			});
			AddFlags(t);
			P("Blood Splatter", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1313292u));
				Splat(px, W, H, 0.44f, 0.36f, 0.17f, 4001, 10359314u, 7211273u, 12589080u);
				Splat(px, W, H, 0.72f, 0.74f, 0.1f, 4002, 8260363u, 5899782u, 10359314u);
			});
			P("Red Rain", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1250072u));
				Drips(px, W, H, 4003, 0.16f, 10358800u, 8260363u);
				Band(px, W, H, 0f, 0.94f, 1f, 1f, C(7211273u));
			});
			P("Void Blood", BgCat.Pattern, delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				Fill(px, W, H, C(854035u));
				Splat(px, W, H, 0.5f, 0.62f, 0.16f, 4004, 5974670u, 4003427u, 10247167u);
				Random random = new Random(4005);
				for (int i = 0; i < 22; i++)
				{
					float cu = 0.2f + 0.6f * (float)random.NextDouble();
					float cv = 0.06f + 0.48f * (float)random.NextDouble();
					float r = Mathf.Lerp(0.004f, 0.011f, (float)random.NextDouble());
					Disc(px, W, H, cu, cv, r, C((i % 3 == 0) ? 13214463u : 10247167u));
				}
			});
			AddBatch72(t);
			AddBatch72Animated(t);
			return t.ToArray();
			void P(string name, BgCat cat, Action<Color32[], int, int> paint)
			{
				t.Add(new Def
				{
					name = name,
					cat = cat,
					paint = paint
				});
			}
		}

		private static void PaintUnionJackCanton(Color32[] px, int W, int H)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(0.5f * (float)W);
			int num2 = Mathf.RoundToInt(0.34f * (float)H);
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < num; j++)
				{
					float num3 = ((float)j + 0.5f) / (float)num;
					float num4 = ((float)i + 0.5f) / (float)num2;
					Color32 c = C(74089u);
					float num5 = Mathf.Abs(num3 - num4);
					float num6 = Mathf.Abs(1f - num3 - num4);
					if (num5 < 0.16f || num6 < 0.16f)
					{
						c = Color32.op_Implicit(Color.white);
					}
					if (num5 < 0.07f || num6 < 0.07f)
					{
						c = C(13111342u);
					}
					if (Mathf.Abs(num3 - 0.5f) < 0.17f || Mathf.Abs(num4 - 0.5f) < 0.17f)
					{
						c = Color32.op_Implicit(Color.white);
					}
					if (Mathf.Abs(num3 - 0.5f) < 0.1f || Mathf.Abs(num4 - 0.5f) < 0.1f)
					{
						c = C(13111342u);
					}
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void DiagBand(Color32[] px, int W, int H, bool rising, float off, float halfW, Color32 c)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Sqrt(3.25f);
			float num2 = (off - halfW) * num;
			float num3 = (off + halfW) * num;
			for (int i = 0; i < H; i++)
			{
				float num4 = ((float)i + 0.5f) / (float)H * 1.5f;
				float num5 = (rising ? ((num2 - num4 + 1.5f) / 1.5f) : ((num4 - num3) / 1.5f));
				float num6 = (rising ? ((num3 - num4 + 1.5f) / 1.5f) : ((num4 - num2) / 1.5f));
				int num7 = Mathf.Max(0, Mathf.FloorToInt(num5 * (float)W));
				int num8 = Mathf.Min(W, Mathf.CeilToInt(num6 * (float)W));
				for (int j = num7; j < num8; j++)
				{
					float num9 = ((float)j + 0.5f) / (float)W;
					float num10 = (rising ? (num4 - 1.5f * (1f - num9)) : (num4 - 1.5f * num9)) / num;
					if (num10 >= off - halfW && num10 <= off + halfW)
					{
						Set(px, W, H, j, i, c);
					}
				}
			}
		}

		private static void Sun(Color32[] px, int W, int H, float cu, float cv, float rDisc, float rRay, int n, Color32 c, float rot = 0f)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			float cq = cv * 1.5f;
			float num = MathF.PI * 11f / 20f / (float)n;
			for (int i = 0; i < n; i++)
			{
				float num2 = rot * (MathF.PI / 180f) + (float)i * 2f * MathF.PI / (float)n;
				Tri(px, W, H, P(num2, rDisc + rRay), P(num2 - num, rDisc * 0.85f), P(num2 + num, rDisc * 0.85f), c);
			}
			Disc(px, W, H, cu, cv, rDisc, c);
			Vector2 P(float ang, float r)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2(cu + r * Mathf.Cos(ang), (cq + r * Mathf.Sin(ang)) / 1.5f);
			}
		}

		private static void Quad(Color32[] px, int W, int H, Vector2 a, Vector2 b, Vector2 c4, Vector2 d, Color32 c)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Tri(px, W, H, a, b, c4, c);
			Tri(px, W, H, a, c4, d, c);
		}

		private static void Rhomb(Color32[] px, int W, int H, float cu, float cv, float ru, float rv, Color32 c)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_0024: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			Tri(px, W, H, new Vector2(cu - ru, cv), new Vector2(cu, cv - rv), new Vector2(cu + ru, cv), c);
			Tri(px, W, H, new Vector2(cu - ru, cv), new Vector2(cu, cv + rv), new Vector2(cu + ru, cv), c);
		}

		private static void ZigzagHoist(Color32[] px, int W, int H, float bandW, int teeth, float amp, Color32 c)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < H; i++)
			{
				float num = Mathf.PingPong(((float)i + 0.5f) / (float)H * (float)teeth * 2f, 1f);
				int num2 = Mathf.Min(W, Mathf.RoundToInt((bandW + amp * (num * 2f - 1f)) * (float)W));
				for (int j = 0; j < num2; j++)
				{
					Set(px, W, H, j, i, c);
				}
			}
		}

		private static void CrossAt(Color32[] px, int W, int H, float cu, float cv, float arm, float thick, Color32 c)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Band(px, W, H, cu - arm, cv - thick / 1.5f, cu + arm, cv + thick / 1.5f, c);
			Band(px, W, H, cu - thick, cv - arm / 1.5f, cu + thick, cv + arm / 1.5f, c);
		}

		private static void AddFlags(List<Def> t)
		{
			P("Afghanistan", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 1052688u, 13836305u, 31286u);
				Disc(px, W, H, 0.5f, 0.5f, 0.07f, Color32.op_Implicit(Color.white));
			});
			P("Albania", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: 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)
				Fill(px, W, H, C(14949920u));
				Tri(px, W, H, V(0.18f, 0.34f), V(0.48f, 0.48f), V(0.18f, 0.62f), C(1052688u));
				Tri(px, W, H, V(0.82f, 0.34f), V(0.52f, 0.48f), V(0.82f, 0.62f), C(1052688u));
				Band(px, W, H, 0.46f, 0.3f, 0.54f, 0.66f, C(1052688u));
				Disc(px, W, H, 0.5f, 0.285f, 0.035f, C(1052688u));
			});
			P("Algeria", delegate(Color32[] px, int W, int H)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 25139u, 16777215u);
				Crescent(px, W, H, 0.49f, 0.5f, 0.13f, 0.05f, 0.11f, C(13766708u));
				Star(px, W, H, 0.575f, 0.5f, 0.05f, 90f, C(13766708u));
			});
			P("Andorra", delegate(Color32[] px, int W, int H)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				VStripesW(px, W, H, new uint[3] { 1050271u, 16702720u, 13959218u }, new float[3] { 1f, 1.2f, 1f });
				Disc(px, W, H, 0.5f, 0.5f, 0.05f, C(13087615u));
			});
			P("Angola", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13371695u, 1052688u);
				Ring(px, W, H, 0.5f, 0.47f, 0.1f, 0.028f, C(16763648u));
				Star(px, W, H, 0.5f, 0.53f, 0.05f, 0f, C(16763648u));
			});
			P("Antigua & Barbuda", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: 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_0047: 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_008b: 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_00a9: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13504806u));
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0.5f, 1f), C(1052688u));
				Sun(px, W, H, 0.5f, 0.22f, 0.055f, 0.045f, 9, C(16568598u));
				Tri(px, W, H, V(0.15f, 0.3f), V(0.85f, 0.3f), V(0.5f, 1f), C(29382u));
				Tri(px, W, H, V(0.24f, 0.48f), V(0.76f, 0.48f), V(0.5f, 1f), Color32.op_Implicit(Color.white));
			});
			P("Argentina", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 7122148u, 16777215u, 7122148u);
				Disc(px, W, H, 0.5f, 0.5f, 0.085f, C(16758812u));
			});
			P("Armenia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 14221330u, 13216u, 15902720u);
			});
			P("Australia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_004f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(74089u));
				Star(px, W, H, 0.28f, 0.72f, 0.1f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.72f, 0.32f, 0.055f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.8f, 0.55f, 0.055f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.63f, 0.6f, 0.045f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.74f, 0.8f, 0.055f, 0f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0f, 0.5f, 0.34f, C(74089u));
				PaintUnionJackCanton(px, W, H);
			});
			P("Austria", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 15676224u, 16777215u, 15676224u);
			});
			P("Azerbaijan", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 37564u, 14942251u, 44902u);
				Crescent(px, W, H, 0.46f, 0.5f, 0.1f, 0.035f, 0.085f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.575f, 0.5f, 0.045f, 90f, Color32.op_Implicit(Color.white));
			});
			P("Bahamas", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 30603u, 16762668u, 30603u);
				Tri(px, W, H, V(0f, 0f), V(0.42f, 0.5f), V(0f, 1f), C(1052688u));
			});
			P("Bahrain", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13504806u));
				ZigzagHoist(px, W, H, 0.32f, 5, 0.06f, Color32.op_Implicit(Color.white));
			});
			P("Bangladesh", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				Fill(px, W, H, C(27214u));
				Disc(px, W, H, 0.45f, 0.5f, 0.16f, C(16001601u));
			});
			P("Barbados", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 9855u, 16762662u, 9855u);
				Band(px, W, H, 0.475f, 0.4f, 0.525f, 0.62f, C(1052688u));
				Band(px, W, H, 0.405f, 0.44f, 0.44f, 0.54f, C(1052688u));
				Band(px, W, H, 0.56f, 0.44f, 0.595f, 0.54f, C(1052688u));
				Tri(px, W, H, V(0.405f, 0.44f), V(0.44f, 0.44f), V(0.4225f, 0.38f), C(1052688u));
				Tri(px, W, H, V(0.56f, 0.44f), V(0.595f, 0.44f), V(0.5775f, 0.38f), C(1052688u));
				Tri(px, W, H, V(0.475f, 0.4f), V(0.525f, 0.4f), V(0.5f, 0.34f), C(1052688u));
			});
			P("Belarus", delegate(Color32[] px, int W, int H)
			{
				//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_0083: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[2] { 13506336u, 31792u }, new float[2] { 2f, 1f });
				Band(px, W, H, 0f, 0f, 0.12f, 1f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 9; i++)
				{
					Rhomb(px, W, H, 0.06f, 0.055f + (float)i * 0.111f, 0.045f, 0.04f, C(13506336u));
				}
			});
			P("Belgium", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 1052688u, 16636452u, 15676224u);
			});
			P("Belize", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: 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_009b: 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)
				Fill(px, W, H, C(16263u));
				Band(px, W, H, 0f, 0f, 1f, 0.08f, C(13504806u));
				Band(px, W, H, 0f, 0.92f, 1f, 1f, C(13504806u));
				Disc(px, W, H, 0.5f, 0.5f, 0.165f, Color32.op_Implicit(Color.white));
				Ring(px, W, H, 0.5f, 0.5f, 0.165f, 0.025f, C(2659328u));
				Disc(px, W, H, 0.5f, 0.5f, 0.045f, C(2659328u));
			});
			P("Benin", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				Band(px, W, H, 0f, 0f, 1f, 0.5f, C(16568598u));
				Band(px, W, H, 0f, 0.5f, 1f, 1f, C(15208749u));
				Band(px, W, H, 0f, 0f, 0.4f, 1f, C(34641u));
			});
			P("Bhutan", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(16766240u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(16731666u));
				Disc(px, W, H, 0.34f, 0.64f, 0.045f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.45f, 0.55f, 0.055f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.56f, 0.46f, 0.045f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.66f, 0.38f, 0.055f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.76f, 0.3f, 0.04f, Color32.op_Implicit(Color.white));
			});
			P("Bolivia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13970206u, 16376576u, 31028u);
			});
			P("Bosnia & Herzegovina", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(5257u));
				Tri(px, W, H, V(0.3f, 0.08f), V(0.88f, 0.08f), V(0.88f, 0.72f), C(16698112u));
				for (int i = 0; i < 5; i++)
				{
					Star(px, W, H, 0.24f + (float)i * 0.13f, 0.11f + (float)i * 0.145f, 0.045f, 0f, Color32.op_Implicit(Color.white));
				}
			});
			P("Botswana", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(7711451u));
				Band(px, W, H, 0f, 0.41f, 1f, 0.59f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.445f, 1f, 0.555f, C(1052688u));
			});
			P("Brazil", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(38713u));
				for (int i = 0; i < H; i++)
				{
					for (int j = 0; j < W; j++)
					{
						float num = ((float)j + 0.5f) / (float)W;
						float num2 = ((float)i + 0.5f) / (float)H;
						if (Mathf.Abs(num - 0.5f) / 0.44f + Mathf.Abs(num2 - 0.5f) / 0.36f <= 1f)
						{
							Set(px, W, H, j, i, C(16702720u));
						}
					}
				}
				Disc(px, W, H, 0.5f, 0.5f, 0.185f, C(74089u));
			});
			P("Brunei", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: 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_0063: 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)
				Fill(px, W, H, C(16244759u));
				DiagBand(px, W, H, rising: false, -0.06f, 0.1f, Color32.op_Implicit(Color.white));
				DiagBand(px, W, H, rising: false, 0.075f, 0.045f, C(1052688u));
				Disc(px, W, H, 0.5f, 0.5f, 0.075f, C(13570342u));
				Band(px, W, H, 0.48f, 0.36f, 0.52f, 0.64f, C(13570342u));
			});
			P("Bulgaria", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16777215u, 38510u, 14034450u);
			});
			P("Burkina Faso", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 15674157u, 40521u);
				Star(px, W, H, 0.5f, 0.5f, 0.09f, 0f, C(16568598u));
			});
			P("Burundi", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(2012474u));
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0.5f, 0.5f), C(13504806u));
				Tri(px, W, H, V(0f, 1f), V(1f, 1f), V(0.5f, 0.5f), C(13504806u));
				DiagBand(px, W, H, rising: true, 0f, 0.045f, Color32.op_Implicit(Color.white));
				DiagBand(px, W, H, rising: false, 0f, 0.045f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.14f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.5f, 0.42f, 0.035f, 0f, C(13504806u));
				Star(px, W, H, 0.44f, 0.55f, 0.035f, 0f, C(13504806u));
				Star(px, W, H, 0.56f, 0.55f, 0.035f, 0f, C(13504806u));
			});
			P("Cabo Verde", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(14483u));
				Band(px, W, H, 0f, 0.55f, 1f, 0.61f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.61f, 1f, 0.67f, C(13574183u));
				Band(px, W, H, 0f, 0.67f, 1f, 0.73f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 10; i++)
				{
					float num = (float)i * MathF.PI * 2f / 10f;
					Star(px, W, H, 0.42f + 0.1f * Mathf.Cos(num), 0.64f + 1f / 15f * Mathf.Sin(num), 0.022f, 0f, C(16240918u));
				}
			});
			P("Cambodia", delegate(Color32[] px, int W, int H)
			{
				//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_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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: 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_0101: 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_011f: 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)
				HStripesW(px, W, H, new uint[3] { 208545u, 14680101u, 208545u }, new float[3] { 1f, 2f, 1f });
				Band(px, W, H, 0.36f, 0.52f, 0.64f, 0.56f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.4f, 0.44f, 0.6f, 0.52f, Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0.38f, 0.44f), V(0.46f, 0.44f), V(0.42f, 0.35f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0.45f, 0.42f), V(0.55f, 0.42f), V(0.5f, 0.31f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0.54f, 0.44f), V(0.62f, 0.44f), V(0.58f, 0.35f), Color32.op_Implicit(Color.white));
			});
			P("Cameroon", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 31326u, 13504806u, 16568598u);
				Star(px, W, H, 0.5f, 0.5f, 0.07f, 0f, C(16568598u));
			});
			P("Canada", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: 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)
				VStripesW(px, W, H, new uint[3] { 14157345u, 16777215u, 14157345u }, new float[3] { 1f, 2f, 1f });
				Star(px, W, H, 0.5f, 0.47f, 0.16f, 0f, C(14157345u));
				Band(px, W, H, 0.485f, 0.56f, 0.515f, 0.66f, C(14157345u));
			});
			P("Central African Republic", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 12418u, 16777215u, 2660136u, 16764416u);
				Band(px, W, H, 0.42f, 0f, 0.58f, 1f, C(13766708u));
				Star(px, W, H, 0.13f, 0.11f, 0.05f, 0f, C(16764416u));
			});
			P("Chad", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 9828u, 16698112u, 12979248u);
			});
			P("Chile", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 14297372u);
				Band(px, W, H, 0f, 0f, 0.36f, 0.5f, C(12960u));
				Star(px, W, H, 0.18f, 0.25f, 0.09f, 0f, Color32.op_Implicit(Color.white));
			});
			P("China", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(15604773u));
				Star(px, W, H, 0.22f, 0.2f, 0.13f, 0f, C(16776960u));
				Star(px, W, H, 0.42f, 0.08f, 0.045f, 20f, C(16776960u));
				Star(px, W, H, 0.48f, 0.17f, 0.045f, 45f, C(16776960u));
				Star(px, W, H, 0.48f, 0.28f, 0.045f, 0f, C(16776960u));
				Star(px, W, H, 0.42f, 0.36f, 0.045f, -20f, C(16776960u));
			});
			P("Colombia", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[3] { 16568598u, 14483u, 13504806u }, new float[3] { 2f, 1f, 1f });
			});
			P("Comoros", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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_0079: 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)
				HStripes(px, W, H, 16762398u, 16777215u, 13504806u, 3831236u);
				Tri(px, W, H, V(0f, 0f), V(0.5f, 0.5f), V(0f, 1f), C(2334278u));
				Crescent(px, W, H, 0.14f, 0.5f, 0.09f, 0.03f, 0.075f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 4; i++)
				{
					Disc(px, W, H, 0.24f, 0.35f + (float)i * 0.1f, 0.014f, Color32.op_Implicit(Color.white));
				}
			});
			P("Congo", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0091: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(38211u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(14427167u));
				DiagBand(px, W, H, rising: true, 0f, 0.1f, C(16506442u));
			});
			P("Cook Islands", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(8283u));
				for (int i = 0; i < 15; i++)
				{
					float num = (float)i * MathF.PI * 2f / 15f;
					Star(px, W, H, 0.62f + 0.16f * Mathf.Cos(num), 0.6f + 0.10666666f * Mathf.Sin(num), 0.022f, 0f, Color32.op_Implicit(Color.white));
				}
				PaintUnionJackCanton(px, W, H);
			});
			P("Costa Rica", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[5] { 11135u, 16777215u, 13504806u, 16777215u, 11135u }, new float[5] { 1f, 1f, 2f, 1f, 1f });
			});
			P("Côte d'Ivoire", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 16744960u, 16777215u, 39492u);
			});
			P("Croatia", delegate(Color32[] px, int W, int H)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16711680u, 16777215u, 1513366u);
				for (int i = 0; i < 4; i++)
				{
					for (int j = 0; j < 5; j++)
					{
						Band(px, W, H, 0.375f + (float)j * 0.05f, 0.38f + (float)i * 0.06f, 0.375f + (float)(j + 1) * 0.05f, 0.38f + (float)(i + 1) * 0.06f, ((j + i) % 2 == 0) ? C(16711680u) : Color32.op_Implicit(Color.white));
					}
				}
			});
			P("Cuba", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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)
				HStripes(px, W, H, 10895u, 16777215u, 10895u, 16777215u, 10895u);
				Tri(px, W, H, V(0f, 0f), V(0.55f, 0.5f), V(0f, 1f), C(13571115u));
				Star(px, W, H, 0.18f, 0.5f, 0.07f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Cyprus", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: 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)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.42f, 0.42f, 0.055f, C(13989888u));
				Disc(px, W, H, 0.52f, 0.4f, 0.05f, C(13989888u));
				Disc(px, W, H, 0.6f, 0.44f, 0.032f, C(13989888u));
				Disc(px, W, H, 0.44f, 0.57f, 0.02f, C(5135153u));
				Disc(px, W, H, 0.5f, 0.59f, 0.02f, C(5135153u));
				Disc(px, W, H, 0.56f, 0.57f, 0.02f, C(5135153u));
			});
			P("Czechia", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 14095386u);
				Tri(px, W, H, V(0f, 0f), V(0.5f, 0.5f), V(0f, 1f), C(1131902u));
			});
			P("DR Congo", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0042: 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)
				Fill(px, W, H, C(32767u));
				DiagBand(px, W, H, rising: true, 0f, 0.11f, C(16242200u));
				DiagBand(px, W, H, rising: true, 0f, 0.075f, C(13504545u));
				Star(px, W, H, 0.16f, 0.13f, 0.08f, 0f, C(16242200u));
			});
			P("Denmark", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13111342u));
				NordicCross(px, W, H, 0.14f, Color32.op_Implicit(Color.white));
			});
			P("Djibouti", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 6992615u, 1223979u);
				Tri(px, W, H, V(0f, 0f), V(0.55f, 0.5f), V(0f, 1f), Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.18f, 0.5f, 0.06f, 0f, C(14095386u));
			});
			P("Dominica", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: 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_010d: 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)
				Fill(px, W, H, C(27455u));
				Band(px, W, H, 0f, 0.44f, 1f, 0.48f, C(16568598u));
				Band(px, W, H, 0f, 0.48f, 1f, 0.52f, C(1052688u));
				Band(px, W, H, 0f, 0.52f, 1f, 0.56f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.44f, 0f, 0.48f, 1f, C(16568598u));
				Band(px, W, H, 0.48f, 0f, 0.52f, 1f, C(1052688u));
				Band(px, W, H, 0.52f, 0f, 0.56f, 1f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.1f, C(13900848u));
				Disc(px, W, H, 0.5f, 0.5f, 0.035f, C(27455u));
			});
			P("Dominican Republic", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_0054: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0f, 0.44f, 0.44f, C(11618u));
				Band(px, W, H, 0.56f, 0f, 1f, 0.44f, C(13504806u));
				Band(px, W, H, 0f, 0.56f, 0.44f, 1f, C(13504806u));
				Band(px, W, H, 0.56f, 0.56f, 1f, 1f, C(11618u));
				Disc(px, W, H, 0.5f, 0.5f, 0.035f, C(27455u));
			});
			P("Ecuador", delegate(Color32[] px, int W, int H)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 16768256u, 216738u, 15539236u }, new float[3] { 2f, 1f, 1f });
				Disc(px, W, H, 0.5f, 0.5f, 0.06f, C(9202239u));
			});
			P("Egypt", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: 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_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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)
				HStripes(px, W, H, 13504806u, 16777215u, 1052688u);
				Disc(px, W, H, 0.5f, 0.47f, 0.045f, C(12620544u));
				Tri(px, W, H, V(0.46f, 0.5f), V(0.54f, 0.5f), V(0.5f, 0.58f), C(12620544u));
			});
			P("El Salvador", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 1001391u, 16777215u, 1001391u);
				Tri(px, W, H, V(0.43f, 0.44f), V(0.57f, 0.44f), V(0.5f, 0.57f), C(13149184u));
				Tri(px, W, H, V(0.455f, 0.46f), V(0.545f, 0.46f), V(0.5f, 0.545f), Color32.op_Implicit(Color.white));
			});
			P("Equatorial Guinea", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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)
				HStripes(px, W, H, 4102656u, 16777215u, 14885144u);
				Tri(px, W, H, V(0f, 0f), V(0.4f, 0.5f), V(0f, 1f), C(29646u));
				Disc(px, W, H, 0.62f, 0.5f, 0.035f, C(10266268u));
			});
			P("Eritrea", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 1223979u, 4295133u);
				Tri(px, W, H, V(0f, 0f), V(1f, 0.5f), V(0f, 1f), C(15336503u));
				Ring(px, W, H, 0.24f, 0.5f, 0.07f, 0.02f, C(16762662u));
				Disc(px, W, H, 0.24f, 0.5f, 0.02f, C(16762662u));
			});
			P("Estonia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 29390u, 1052688u, 16777215u);
			});
			P("Eswatini", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 4087481u, 16767232u, 11602956u, 16767232u, 4087481u }, new float[5] { 3f, 1f, 5f, 1f, 3f });
				Band(px, W, H, 0.2f, 0.49f, 0.8f, 0.51f, C(10709803u));
				Disc(px, W, H, 0.42f, 0.5f, 0.075f, C(1052688u));
				Disc(px, W, H, 0.58f, 0.5f, 0.075f, C(1052688u));
				Disc(px, W, H, 0.5f, 0.5f, 0.085f, C(1052688u));
				Disc(px, W, H, 0.44f, 0.5f, 0.055f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.53f, 0.5f, 0.04f, Color32.op_Implicit(Color.white));
			});
			P("Ethiopia", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 493872u, 16571657u, 14291482u);
				Disc(px, W, H, 0.5f, 0.5f, 0.13f, C(1001391u));
				Star(px, W, H, 0.5f, 0.5f, 0.1f, 0f, C(16571657u));
				Star(px, W, H, 0.5f, 0.5f, 0.055f, 0f, C(1001391u));
			});
			P("Fiji", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_0054: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(6864869u));
				Band(px, W, H, 0.6f, 0.52f, 0.82f, 0.78f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.6f, 0.52f, 0.82f, 0.58f, C(13766708u));
				Band(px, W, H, 0.695f, 0.58f, 0.725f, 0.78f, C(13766708u));
				Band(px, W, H, 0.6f, 0.655f, 0.82f, 0.685f, C(13766708u));
				PaintUnionJackCanton(px, W, H);
			});
			P("Finland", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				NordicCross(px, W, H, 0.16f, C(12140u));
			});
			P("France", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 21924u, 16777215u, 15679797u);
			});
			P("Gabon", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 40544u, 16568598u, 3831236u);
			});
			P("Gambia", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[5] { 13504806u, 16777215u, 793740u, 16777215u, 3831592u }, new float[5] { 6f, 1f, 4f, 1f, 6f });
			});
			P("Georgia", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_0054: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.44f, 0f, 0.56f, 1f, C(16711680u));
				Band(px, W, H, 0f, 0.46f, 1f, 0.54f, C(16711680u));
				CrossAt(px, W, H, 0.22f, 0.22f, 0.05f, 0.018f, C(16711680u));
				CrossAt(px, W, H, 0.78f, 0.22f, 0.05f, 0.018f, C(16711680u));
				CrossAt(px, W, H, 0.22f, 0.78f, 0.05f, 0.018f, C(16711680u));
				CrossAt(px, W, H, 0.78f, 0.78f, 0.05f, 0.018f, C(16711680u));
			});
			P("Germany", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 1052688u, 14483456u, 16764416u);
			});
			P("Ghana", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 15676224u, 16765184u, 38713u);
				Star(px, W, H, 0.5f, 0.5f, 0.1f, 0f, C(1052688u));
			});
			P("Greece", delegate(Color32[] px, int W, int H)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: 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)
				HStripes(px, W, H, 876207u, 16777215u, 876207u, 16777215u, 876207u, 16777215u, 876207u, 16777215u, 876207u);
				Band(px, W, H, 0f, 0f, 0.37f, 0.37f, C(876207u));
				Band(px, W, H, 0.145f, 0f, 0.225f, 0.37f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.145f, 0.37f, 0.225f, Color32.op_Implicit(Color.white));
			});
			P("Grenada", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: 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_00bb: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: 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_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e3: 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_022f: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13504806u));
				Tri(px, W, H, V(0.09f, 0.09f), V(0.91f, 0.09f), V(0.5f, 0.5f), C(16568598u));
				Tri(px, W, H, V(0.09f, 0.91f), V(0.91f, 0.91f), V(0.5f, 0.5f), C(16568598u));
				Tri(px, W, H, V(0.09f, 0.09f), V(0.5f, 0.5f), V(0.09f, 0.91f), C(31326u));
				Tri(px, W, H, V(0.91f, 0.09f), V(0.5f, 0.5f), V(0.91f, 0.91f), C(31326u));
				Disc(px, W, H, 0.5f, 0.5f, 0.075f, C(13504806u));
				Star(px, W, H, 0.5f, 0.5f, 0.055f, 0f, C(16568598u));
				Star(px, W, H, 0.3f, 0.045f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.5f, 0.045f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.7f, 0.045f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.3f, 0.955f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.5f, 0.955f, 0.03f, 0f, C(16568598u));
				Star(px, W, H, 0.7f, 0.955f, 0.03f, 0f, C(16568598u));
			});
			P("Guatemala", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 4822992u, 16777215u, 4822992u);
				Ring(px, W, H, 0.5f, 0.5f, 0.07f, 0.015f, C(1089102u));
				Disc(px, W, H, 0.5f, 0.5f, 0.03f, C(9214808u));
			});
			P("Guinea", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 13504806u, 16568598u, 37984u);
			});
			P("Guinea-Bissau", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: 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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				Band(px, W, H, 0.35f, 0f, 1f, 0.5f, C(16568598u));
				Band(px, W, H, 0.35f, 0.5f, 1f, 1f, C(40521u));
				Band(px, W, H, 0f, 0f, 0.35f, 1f, C(13504806u));
				Star(px, W, H, 0.175f, 0.5f, 0.07f, 0f, C(1052688u));
			});
			P("Guyana", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: 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_00bb: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: 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)
				Fill(px, W, H, C(40521u));
				Tri(px, W, H, V(0f, 0.02f), V(0.98f, 0.5f), V(0f, 0.98f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0f, 0.06f), V(0.9f, 0.5f), V(0f, 0.94f), C(16568598u));
				Tri(px, W, H, V(0f, 0.14f), V(0.55f, 0.5f), V(0f, 0.86f), C(1052688u));
				Tri(px, W, H, V(0f, 0.2f), V(0.47f, 0.5f), V(0f, 0.8f), C(13504806u));
			});
			P("Haiti", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 8351u, 13766708u);
				Band(px, W, H, 0.42f, 0.42f, 0.58f, 0.58f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.032f, C(92694u));
			});
			P("Honduras", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 29647u, 16777215u, 29647u);
				Star(px, W, H, 0.35f, 0.42f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.65f, 0.42f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.5f, 0.5f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.35f, 0.58f, 0.032f, 0f, C(29647u));
				Star(px, W, H, 0.65f, 0.58f, 0.032f, 0f, C(29647u));
			});
			P("Hungary", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13510969u, 16777215u, 4681808u);
			});
			P("Iceland", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(152220u));
				NordicCross(px, W, H, 0.16f, Color32.op_Implicit(Color.white));
				NordicCross(px, W, H, 0.08f, C(14425653u));
			});
			P("India", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16750899u, 16777215u, 1280008u);
				Ring(px, W, H, 0.5f, 0.5f, 0.105f, 0.028f, C(128u));
			});
			P("Indonesia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13504806u, 16777215u);
			});
			P("Iran", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 2334528u, 16777215u, 14286848u);
				Disc(px, W, H, 0.5f, 0.5f, 0.05f, C(14286848u));
				Band(px, W, H, 0.485f, 0.42f, 0.515f, 0.58f, C(14286848u));
			});
			P("Iraq", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13504806u, 16777215u, 1052688u);
				Disc(px, W, H, 0.38f, 0.5f, 0.028f, C(31293u));
				Disc(px, W, H, 0.5f, 0.49f, 0.028f, C(31293u));
				Disc(px, W, H, 0.62f, 0.5f, 0.028f, C(31293u));
			});
			P("Ireland", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 1481570u, 16777215u, 16746558u);
			});
			P("Israel", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: 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_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: 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_00c8: 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)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.12f, 1f, 0.22f, C(14520u));
				Band(px, W, H, 0f, 0.78f, 1f, 0.88f, C(14520u));
				Tri(px, W, H, V(0.5f, 0.32f), V(0.35f, 0.5f), V(0.65f, 0.5f), C(14520u));
				Tri(px, W, H, V(0.5f, 0.62f), V(0.35f, 0.44f), V(0.65f, 0.44f), C(14520u));
			});
			P("Italy", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 35909u, 16777215u, 13443370u);
			});
			P("Jamaica", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_008b: 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_00a9: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: 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_012c: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0.5f, 0.5f), C(39738u));
				Tri(px, W, H, V(0f, 1f), V(1f, 1f), V(0.5f, 0.5f), C(39738u));
				Tri(px, W, H, V(0f, 0f), V(0.5f, 0.5f), V(0f, 1f), C(1052688u));
				Tri(px, W, H, V(1f, 0f), V(0.5f, 0.5f), V(1f, 1f), C(1052688u));
				DiagBand(px, W, H, rising: true, 0f, 0.05f, C(16699648u));
				DiagBand(px, W, H, rising: false, 0f, 0.05f, C(16699648u));
			});
			P("Japan", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.19f, C(12320813u));
			});
			P("Jordan", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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)
				HStripes(px, W, H, 1052688u, 16777215u, 31293u);
				Tri(px, W, H, V(0f, 0f), V(0.45f, 0.5f), V(0f, 1f), C(13504806u));
				Star(px, W, H, 0.15f, 0.5f, 0.035f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Kazakhstan", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0061: 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_00ad: 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_00cb: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(45002u));
				Band(px, W, H, 0.02f, 0f, 0.1f, 1f, C(16696588u));
				for (int i = 0; i < 8; i++)
				{
					Rhomb(px, W, H, 0.06f, 0.06f + (float)i * 0.125f, 0.032f, 0.035f, C(45002u));
				}
				Sun(px, W, H, 0.55f, 0.4f, 0.09f, 0.05f, 16, C(16696588u));
				Quad(px, W, H, V(0.35f, 0.62f), V(0.55f, 0.58f), V(0.75f, 0.62f), V(0.55f, 0.66f), C(16696588u));
			});
			P("Kenya", delegate(Color32[] px, int W, int H)
			{
				//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_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 1052688u, 16777215u, 12255232u, 16777215u, 26112u }, new float[5] { 6f, 1f, 6f, 1f, 6f });
				Band(px, W, H, 0.49f, 0.22f, 0.51f, 0.78f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.085f, C(12255232u));
				Ring(px, W, H, 0.5f, 0.5f, 0.085f, 0.018f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.035f, C(1052688u));
			});
			P("Kiribati", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: 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_0088: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				Band(px, W, H, 0f, 0f, 1f, 0.55f, C(15154733u));
				Sun(px, W, H, 0.5f, 0.42f, 0.08f, 0.05f, 12, C(16697162u));
				Tri(px, W, H, V(0.36f, 0.21f), V(0.5f, 0.15f), V(0.64f, 0.21f), C(16697162u));
				for (int i = 0; i < 6; i++)
				{
					Band(px, W, H, 0f, 0.55f + (float)i * 0.075f, 1f, 0.55f + (float)(i + 1) * 0.075f, (i % 2 == 0) ? C(23196u) : Color32.op_Implicit(Color.white));
				}
			});
			P("Kosovo", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(2378405u));
				Disc(px, W, H, 0.5f, 0.56f, 0.09f, C(13674064u));
				Disc(px, W, H, 0.43f, 0.61f, 0.05f, C(13674064u));
				Disc(px, W, H, 0.57f, 0.61f, 0.05f, C(13674064u));
				for (int i = 0; i < 6; i++)
				{
					Star(px, W, H, 0.29f + (float)i * 0.084f, (i < 3) ? (0.33f - (float)i * 0.028f) : (0.252f + (float)(i - 3) * 0.028f), 0.028f, 0f, Color32.op_Implicit(Color.white));
				}
			});
			P("Kuwait", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 31293u, 16777215u, 13504806u);
				Quad(px, W, H, V(0f, 0f), V(0.32f, 0.25f), V(0.32f, 0.75f), V(0f, 1f), C(1052688u));
			});
			P("Kyrgyzstan", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(15208749u));
				Sun(px, W, H, 0.5f, 0.5f, 0.1f, 0.05f, 20, C(16772864u));
				Ring(px, W, H, 0.5f, 0.5f, 0.055f, 0.014f, C(15208749u));
				Band(px, W, H, 0.45f, 0.487f, 0.55f, 0.513f, C(15208749u));
				Band(px, W, H, 0.487f, 0.467f, 0.513f, 0.533f, C(15208749u));
			});
			P("Laos", delegate(Color32[] px, int W, int H)
			{
				//IL_003c: 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)
				HStripesW(px, W, H, new uint[3] { 13504806u, 10344u, 13504806u }, new float[3] { 1f, 2f, 1f });
				Disc(px, W, H, 0.5f, 0.5f, 0.11f, Color32.op_Implicit(Color.white));
			});
			P("Latvia", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[3] { 10367033u, 16777215u, 10367033u }, new float[3] { 2f, 1f, 2f });
			});
			P("Lebanon", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 15603231u, 16777215u, 15603231u }, new float[3] { 1f, 2f, 1f });
				Band(px, W, H, 0.485f, 0.54f, 0.515f, 0.62f, C(8014627u));
				Tri(px, W, H, V(0.38f, 0.56f), V(0.62f, 0.56f), V(0.5f, 0.42f), C(42577u));
				Tri(px, W, H, V(0.41f, 0.48f), V(0.59f, 0.48f), V(0.5f, 0.35f), C(42577u));
			});
			P("Lesotho", delegate(Color32[] px, int W, int H)
			{
				//IL_0037: 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_0055: 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_0085: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 8351u, 16777215u, 38211u }, new float[3] { 3f, 4f, 3f });
				Tri(px, W, H, V(0.42f, 0.55f), V(0.58f, 0.55f), V(0.5f, 0.38f), C(1052688u));
				Band(px, W, H, 0.38f, 0.55f, 0.62f, 0.575f, C(1052688u));
			});
			P("Liberia", delegate(Color32[] px, int W, int H)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 12519984u, 16777215u, 12519984u, 16777215u, 12519984u, 16777215u, 12519984u, 16777215u, 12519984u, 16777215u, 12519984u);
				Band(px, W, H, 0f, 0f, 0.45f, 0.32f, C(10344u));
				Star(px, W, H, 0.225f, 0.16f, 0.09f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Libya", delegate(Color32[] px, int W, int H)
			{
				//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_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 15138835u, 1052688u, 2334278u }, new float[3] { 1f, 2f, 1f });
				Crescent(px, W, H, 0.45f, 0.5f, 0.09f, 0.03f, 0.075f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.56f, 0.5f, 0.04f, 90f, Color32.op_Implicit(Color.white));
			});
			P("Liechtenstein", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: 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_00ae: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: 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)
				HStripes(px, W, H, 11135u, 13504806u);
				Band(px, W, H, 0.1f, 0.14f, 0.26f, 0.2f, C(16767037u));
				Tri(px, W, H, V(0.1f, 0.14f), V(0.14f, 0.14f), V(0.12f, 0.1f), C(16767037u));
				Tri(px, W, H, V(0.16f, 0.14f), V(0.2f, 0.14f), V(0.18f, 0.09f), C(16767037u));
				Tri(px, W, H, V(0.22f, 0.14f), V(0.26f, 0.14f), V(0.24f, 0.1f), C(16767037u));
			});
			P("Lithuania", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16627987u, 27204u, 12658477u);
			});
			P("Luxembourg", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 15340573u, 16777215u, 5352922u);
			});
			P("Madagascar", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: 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_0063: 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)
				Band(px, W, H, 0.33f, 0f, 1f, 0.5f, C(16530738u));
				Band(px, W, H, 0.33f, 0.5f, 1f, 1f, C(32314u));
				Band(px, W, H, 0f, 0f, 0.33f, 1f, Color32.op_Implicit(Color.white));
			});
			P("Malawi", delegate(Color32[] px, int W, int H)
			{
				//IL_0037: 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)
				HStripes(px, W, H, 1052688u, 13504806u, 3382837u);
				Sun(px, W, H, 0.5f, 0.335f, 0.09f, 0.06f, 9, C(13504806u));
				Band(px, W, H, 0f, 0.336f, 1f, 0.667f, C(13504806u));
			});
			P("Malaysia", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13369345u, 16777215u, 13369345u, 16777215u, 13369345u, 16777215u, 13369345u);
				Band(px, W, H, 0f, 0f, 0.5f, 0.3f, C(65638u));
				Crescent(px, W, H, 0.17f, 0.15f, 0.08f, 0.03f, 0.065f, C(16763904u));
				Star(px, W, H, 0.33f, 0.15f, 0.055f, 0f, C(16763904u));
			});
			P("Maldives", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_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)
				Fill(px, W, H, C(13766708u));
				Band(px, W, H, 0.2f, 0.25f, 0.8f, 0.75f, C(32314u));
				Crescent(px, W, H, 0.52f, 0.5f, 0.1f, 0.045f, 0.085f, Color32.op_Implicit(Color.white));
			});
			P("Mali", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 1357114u, 16568598u, 13504806u);
			});
			P("Malta", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 16777215u, 13571115u);
				CrossAt(px, W, H, 0.12f, 0.11f, 0.045f, 0.016f, C(10329500u));
			});
			P("Marshall Islands", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: 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)
				Fill(px, W, H, C(14483u));
				DiagBand(px, W, H, rising: true, -0.05f, 0.05f, C(14513408u));
				DiagBand(px, W, H, rising: true, 0.05f, 0.05f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.28f, 0.2f, 0.1f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Mauritania", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: 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_0096: 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)
				Fill(px, W, H, C(43356u));
				Band(px, W, H, 0f, 0f, 1f, 0.12f, C(13638687u));
				Band(px, W, H, 0f, 0.88f, 1f, 1f, C(13638687u));
				Disc(px, W, H, 0.5f, 0.52f, 0.14f, C(16766720u));
				Disc(px, W, H, 0.5f, 0.44f, 0.13f, C(43356u));
				Star(px, W, H, 0.5f, 0.4f, 0.05f, 0f, C(16766720u));
			});
			P("Mauritius", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 15345721u, 1712237u, 16766208u, 42321u);
			});
			P("Mexico", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 25409u, 16777215u, 13111342u);
				Disc(px, W, H, 0.5f, 0.5f, 0.055f, C(9202239u));
			});
			P("Micronesia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_004f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: 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)
				Fill(px, W, H, C(7713501u));
				Star(px, W, H, 0.5f, 0.25f, 0.05f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.5f, 0.75f, 0.05f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.28f, 0.5f, 0.05f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.72f, 0.5f, 0.05f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Moldova", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 18094u, 16765440u, 13371695u);
				Disc(px, W, H, 0.5f, 0.5f, 0.05f, C(9202239u));
			});
			P("Monaco", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13504806u, 16777215u);
			});
			P("Mongolia", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 12855087u, 86423u, 12855087u);
				Tri(px, W, H, V(0.145f, 0.35f), V(0.19f, 0.35f), V(0.167f, 0.29f), C(16371458u));
				Disc(px, W, H, 0.167f, 0.4f, 0.03f, C(16371458u));
				Band(px, W, H, 0.13f, 0.445f, 0.205f, 0.465f, C(16371458u));
				Disc(px, W, H, 0.167f, 0.51f, 0.026f, C(16371458u));
				Band(px, W, H, 0.13f, 0.555f, 0.205f, 0.575f, C(16371458u));
				Band(px, W, H, 0.126f, 0.44f, 0.14f, 0.58f, C(16371458u));
				Band(px, W, H, 0.194f, 0.44f, 0.208f, 0.58f, C(16371458u));
			});
			P("Montenegro", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: 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_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: 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_00c8: 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)
				Fill(px, W, H, C(13872699u));
				Band(px, W, H, 0.025f, 0.025f, 0.975f, 0.975f, C(12845832u));
				Star(px, W, H, 0.5f, 0.42f, 0.07f, 0f, C(13872699u));
				Tri(px, W, H, V(0.36f, 0.5f), V(0.5f, 0.44f), V(0.5f, 0.56f), C(13872699u));
				Tri(px, W, H, V(0.64f, 0.5f), V(0.5f, 0.44f), V(0.5f, 0.56f), C(13872699u));
			});
			P("Morocco", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(12658477u));
				Star(px, W, H, 0.5f, 0.5f, 0.11f, 0f, C(25139u));
				Star(px, W, H, 0.5f, 0.505f, 0.05f, 0f, C(12658477u));
			});
			P("Mozambique", delegate(Color32[] px, int W, int H)
			{
				//IL_0037: 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_0055: 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_0085: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 38457u, 16777215u, 1052688u, 16777215u, 16572672u }, new float[5] { 5f, 1f, 5f, 1f, 5f });
				Tri(px, W, H, V(0f, 0f), V(0.48f, 0.5f), V(0f, 1f), C(14942251u));
				Star(px, W, H, 0.16f, 0.5f, 0.07f, 0f, C(16572672u));
			});
			P("Myanmar", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16698112u, 3453491u, 15345721u);
				Star(px, W, H, 0.5f, 0.5f, 0.14f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Namibia", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_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_00ae: 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)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(13696u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(38211u));
				DiagBand(px, W, H, rising: true, 0f, 0.1f, Color32.op_Implicit(Color.white));
				DiagBand(px, W, H, rising: true, 0f, 0.075f, C(13766708u));
				Sun(px, W, H, 0.2f, 0.15f, 0.05f, 0.035f, 12, C(16764416u));
			});
			P("Nauru", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_004f: 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)
				Fill(px, W, H, C(11135u));
				Band(px, W, H, 0f, 0.48f, 1f, 0.52f, C(16762398u));
				Star(px, W, H, 0.25f, 0.66f, 0.06f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Nepal", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: 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_00bb: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: 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_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(1250072u));
				Tri(px, W, H, V(0.14f, 0.03f), V(0.8f, 0.29f), V(0.14f, 0.55f), C(14483u));
				Tri(px, W, H, V(0.17f, 0.08f), V(0.72f, 0.29f), V(0.17f, 0.5f), C(14423100u));
				Tri(px, W, H, V(0.14f, 0.44f), V(0.86f, 0.72f), V(0.14f, 1f), C(14483u));
				Tri(px, W, H, V(0.17f, 0.5f), V(0.78f, 0.72f), V(0.17f, 0.94f), C(14423100u));
				Disc(px, W, H, 0.33f, 0.3f, 0.045f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.33f, 0.266f, 0.042f, C(14423100u));
				Sun(px, W, H, 0.33f, 0.73f, 0.032f, 0.022f, 12, Color32.op_Implicit(Color.white));
			});
			P("Netherlands", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 11410472u, 16777215u, 2180747u);
			});
			P("New Zealand", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(74089u));
				Star(px, W, H, 0.72f, 0.34f, 0.05f, 0f, C(13374507u));
				Star(px, W, H, 0.8f, 0.55f, 0.05f, 0f, C(13374507u));
				Star(px, W, H, 0.64f, 0.58f, 0.045f, 0f, C(13374507u));
				Star(px, W, H, 0.72f, 0.78f, 0.05f, 0f, C(13374507u));
				PaintUnionJackCanton(px, W, H);
			});
			P("Nicaragua", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 26566u, 16777215u, 26566u);
				Tri(px, W, H, V(0.43f, 0.44f), V(0.57f, 0.44f), V(0.5f, 0.57f), C(13149184u));
				Tri(px, W, H, V(0.455f, 0.46f), V(0.545f, 0.46f), V(0.5f, 0.545f), Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.48f, 0.018f, C(26566u));
			});
			P("Niger", delegate(Color32[] px, int W, int H)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 14701062u, 16777215u, 897067u);
				Disc(px, W, H, 0.5f, 0.5f, 0.075f, C(14701062u));
			});
			P("Nigeria", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 34641u, 16777215u, 34641u);
			});
			P("Niue", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16702720u));
				PaintUnionJackCanton(px, W, H);
				Disc(px, W, H, 0.25f, 0.17f, 0.045f, C(16702720u));
				Star(px, W, H, 0.25f, 0.17f, 0.032f, 0f, C(74089u));
				Star(px, W, H, 0.25f, 0.055f, 0.02f, 0f, C(16702720u));
				Star(px, W, H, 0.25f, 0.285f, 0.02f, 0f, C(16702720u));
				Star(px, W, H, 0.1f, 0.17f, 0.02f, 0f, C(16702720u));
				Star(px, W, H, 0.4f, 0.17f, 0.02f, 0f, C(16702720u));
			});
			P("North Korea", delegate(Color32[] px, int W, int H)
			{
				//IL_003c: 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_0067: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 151458u, 16777215u, 15539239u, 16777215u, 151458u }, new float[5] { 6f, 1f, 11f, 1f, 6f });
				Disc(px, W, H, 0.32f, 0.5f, 0.1f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.32f, 0.5f, 0.078f, 0f, C(15539239u));
			});
			P("North Macedonia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(13762560u));
				Sun(px, W, H, 0.5f, 0.5f, 0.09f, 0.6f, 8, C(16769674u));
			});
			P("Norway", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(12192815u));
				NordicCross(px, W, H, 0.16f, Color32.op_Implicit(Color.white));
				NordicCross(px, W, H, 0.08f, C(8283u));
			});
			P("Oman", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				HStripes(px, W, H, 16777215u, 14358043u, 32768u);
				Band(px, W, H, 0f, 0f, 0.28f, 1f, C(14358043u));
				Disc(px, W, H, 0.14f, 0.1f, 0.03f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.13f, 0.12f, 0.15f, 0.24f, Color32.op_Implicit(Color.white));
			});
			P("Pakistan", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//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_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)
				Fill(px, W, H, C(82204u));
				Band(px, W, H, 0f, 0f, 0.25f, 1f, Color32.op_Implicit(Color.white));
				Crescent(px, W, H, 0.58f, 0.48f, 0.15f, 0.05f, 0.13f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.71f, 0.35f, 0.06f, 20f, Color32.op_Implicit(Color.white));
			});
			P("Palau", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				Fill(px, W, H, C(4894166u));
				Disc(px, W, H, 0.45f, 0.5f, 0.15f, C(16768512u));
			});
			P("Palestine", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 1052688u, 16777215u, 38710u);
				Tri(px, W, H, V(0f, 0f), V(0.45f, 0.5f), V(0f, 1f), C(15608373u));
			});
			P("Panama", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_0054: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.5f, 0f, 1f, 0.5f, C(13766708u));
				Band(px, W, H, 0f, 0.5f, 0.5f, 1f, C(21139u));
				Star(px, W, H, 0.25f, 0.25f, 0.07f, 0f, C(21139u));
				Star(px, W, H, 0.75f, 0.75f, 0.07f, 0f, C(13766708u));
			});
			P("Papua New Guinea", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0095: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: 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_0146: 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_016c: 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_0192: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(1f, 1f), C(13504806u));
				Tri(px, W, H, V(0f, 0f), V(1f, 1f), V(0f, 1f), C(1052688u));
				Disc(px, W, H, 0.68f, 0.26f, 0.05f, C(16763653u));
				Tri(px, W, H, V(0.58f, 0.22f), V(0.78f, 0.14f), V(0.68f, 0.28f), C(16763653u));
				Star(px, W, H, 0.25f, 0.52f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.33f, 0.63f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.25f, 0.76f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.17f, 0.63f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.28f, 0.67f, 0.022f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Paraguay", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13970206u, 16777215u, 14504u);
				Ring(px, W, H, 0.5f, 0.5f, 0.07f, 0.015f, C(39738u));
				Star(px, W, H, 0.5f, 0.5f, 0.035f, 0f, C(16761358u));
			});
			P("Peru", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 14225443u, 16777215u, 14225443u);
			});
			P("Philippines", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: 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)
				HStripes(px, W, H, 14504u, 13504806u);
				Tri(px, W, H, V(0f, 0f), V(0.5f, 0.5f), V(0f, 1f), Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.15f, 0.5f, 0.07f, C(16568598u));
			});
			P("Poland", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16777215u, 14423100u);
			});
			P("Portugal", delegate(Color32[] px, int W, int H)
			{
				//IL_004b: 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)
				VStripesW(px, W, H, new uint[2] { 289336u, 14297372u }, new float[2] { 2f, 3f });
				Disc(px, W, H, 0.4f, 0.5f, 0.11f, C(16771328u));
				Disc(px, W, H, 0.4f, 0.5f, 0.062f, C(14297372u));
			});
			P("Qatar", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(9247549u));
				ZigzagHoist(px, W, H, 0.3f, 9, 0.045f, Color32.op_Implicit(Color.white));
			});
			P("Romania", delegate(Color32[] px, int W, int H)
			{
				VStripes(px, W, H, 11135u, 16568598u, 13504806u);
			});
			P("Russia", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 16777215u, 14758u, 13970206u);
			});
			P("Rwanda", delegate(Color32[] px, int W, int H)
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 41438u, 16437761u, 2121789u }, new float[3] { 2f, 1f, 1f });
				Sun(px, W, H, 0.78f, 0.14f, 0.05f, 0.035f, 12, C(15056385u));
			});
			P("Saint Kitts & Nevis", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: 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)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(40521u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(13504806u));
				DiagBand(px, W, H, rising: true, 0f, 0.14f, C(16568598u));
				DiagBand(px, W, H, rising: true, 0f, 0.1f, C(1052688u));
				Star(px, W, H, 0.37f, 0.56f, 0.05f, 20f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.63f, 0.44f, 0.05f, 20f, Color32.op_Implicit(Color.white));
			});
			P("Saint Lucia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: 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_00bb: 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)
				Fill(px, W, H, C(6737151u));
				Tri(px, W, H, V(0.28f, 0.78f), V(0.72f, 0.78f), V(0.5f, 0.22f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0.32f, 0.78f), V(0.68f, 0.78f), V(0.5f, 0.28f), C(1052688u));
				Tri(px, W, H, V(0.28f, 0.78f), V(0.72f, 0.78f), V(0.5f, 0.5f), C(16568598u));
			});
			P("Saint Vincent", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: 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_0092: Unknown result type (might be due to invalid IL or missing references)
				VStripesW(px, W, H, new uint[3] { 29382u, 16568598u, 40544u }, new float[3] { 1f, 2f, 1f });
				Rhomb(px, W, H, 0.41f, 0.45f, 0.05f, 0.055f, C(40544u));
				Rhomb(px, W, H, 0.59f, 0.45f, 0.05f, 0.055f, C(40544u));
				Rhomb(px, W, H, 0.5f, 0.57f, 0.05f, 0.055f, C(40544u));
			});
			P("Samoa", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_004f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: 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)
				Fill(px, W, H, C(13504806u));
				Band(px, W, H, 0f, 0f, 0.5f, 0.34f, C(11135u));
				Star(px, W, H, 0.25f, 0.08f, 0.035f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.32f, 0.15f, 0.035f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.25f, 0.24f, 0.035f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.17f, 0.16f, 0.035f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.28f, 0.19f, 0.024f, 0f, Color32.op_Implicit(Color.white));
			});
			P("San Marino", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 6207204u);
				Ring(px, W, H, 0.5f, 0.5f, 0.07f, 0.015f, C(1089102u));
				Disc(px, W, H, 0.5f, 0.5f, 0.035f, C(15188318u));
			});
			P("São Tomé & Príncipe", delegate(Color32[] px, int W, int H)
			{
				//IL_0037: 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_0055: 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_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 1223979u, 16764416u, 1223979u }, new float[3] { 1f, 2f, 1f });
				Tri(px, W, H, V(0f, 0f), V(0.3f, 0.5f), V(0f, 1f), C(13766708u));
				Star(px, W, H, 0.53f, 0.5f, 0.05f, 0f, C(1052688u));
				Star(px, W, H, 0.75f, 0.5f, 0.05f, 0f, C(1052688u));
			});
			P("Saudi Arabia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_004f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: 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_010d: 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_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(27701u));
				Band(px, W, H, 0.2f, 0.345f, 0.34f, 0.375f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.38f, 0.335f, 0.52f, 0.375f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.56f, 0.345f, 0.66f, 0.375f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.7f, 0.335f, 0.8f, 0.375f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.26f, 0.42f, 0.44f, 0.45f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.5f, 0.41f, 0.74f, 0.45f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.2f, 0.575f, 0.76f, 0.605f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.76f, 0.565f, 0.8f, 0.615f, Color32.op_Implicit(Color.white));
			});
			P("Senegal", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 34111u, 16641858u, 14883619u);
				Star(px, W, H, 0.5f, 0.5f, 0.07f, 0f, C(34111u));
			});
			P("Serbia", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 12990012u, 802934u, 16777215u);
				Band(px, W, H, 0.32f, 0.4f, 0.44f, 0.6f, C(12990012u));
				CrossAt(px, W, H, 0.38f, 0.5f, 0.045f, 0.014f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.38f, 0.375f, 0.025f, C(15579438u));
			});
			P("Seychelles", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_008b: 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_00a9: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: 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_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 1f), V(0f, 0f), V(0.33f, 0f), C(16263u));
				Tri(px, W, H, V(0f, 1f), V(0.33f, 0f), V(0.66f, 0f), C(16570454u));
				Tri(px, W, H, V(0f, 1f), V(0.66f, 0f), V(1f, 0f), C(14034984u));
				Tri(px, W, H, V(0f, 1f), V(1f, 0f), V(1f, 0.5f), Color32.op_Implicit(Color.white));
				Tri(px, W, H, V(0f, 1f), V(1f, 0.5f), V(1f, 1f), C(31293u));
			});
			P("Sierra Leone", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 2012474u, 16777215u, 29382u);
			});
			P("Singapore", delegate(Color32[] px, int W, int H)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: 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)
				HStripes(px, W, H, 15676224u, 16777215u);
				Crescent(px, W, H, 0.2f, 0.25f, 0.1f, 0.035f, 0.085f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 5; i++)
				{
					float num = (-90f + (float)i * 72f) * (MathF.PI / 180f);
					Star(px, W, H, 0.34f + 0.045f * Mathf.Cos(num), 0.25f + 0.030000001f * Mathf.Sin(num), 0.018f, 0f, Color32.op_Implicit(Color.white));
				}
			});
			P("Slovakia", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00c8: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 741026u, 15604773u);
				Band(px, W, H, 0.22f, 0.38f, 0.38f, 0.62f, C(15604773u));
				Band(px, W, H, 0.29f, 0.42f, 0.31f, 0.56f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.25f, 0.45f, 0.35f, 0.475f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.26f, 0.505f, 0.34f, 0.53f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.3f, 0.6f, 0.032f, C(741026u));
			});
			P("Slovenia", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 23972u, 15539236u);
				Band(px, W, H, 0.19f, 0.15f, 0.31f, 0.37f, C(23972u));
				Tri(px, W, H, V(0.2f, 0.32f), V(0.25f, 0.22f), V(0.3f, 0.32f), Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.22f, 0.185f, 0.011f, C(16768256u));
				Disc(px, W, H, 0.28f, 0.185f, 0.011f, C(16768256u));
				Disc(px, W, H, 0.25f, 0.165f, 0.011f, C(16768256u));
			});
			P("Solomon Islands", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(20922u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(2186035u));
				DiagBand(px, W, H, rising: true, 0f, 0.05f, C(16568598u));
				Star(px, W, H, 0.13f, 0.1f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.29f, 0.1f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.21f, 0.185f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.13f, 0.27f, 0.032f, 0f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.29f, 0.27f, 0.032f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Somalia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				Fill(px, W, H, C(4295133u));
				Star(px, W, H, 0.5f, 0.5f, 0.13f, 0f, Color32.op_Implicit(Color.white));
			});
			P("South Africa", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: 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_00b6: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 14695473u, 5257u);
				Band(px, W, H, 0f, 0.4f, 1f, 0.6f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0f, 0.44f, 1f, 0.56f, C(30537u));
				Tri(px, W, H, V(-0.02f, -0.05f), V(0.42f, 0.5f), V(-0.02f, 1.05f), C(16758812u));
				Tri(px, W, H, V(-0.02f, 0.1f), V(0.3f, 0.5f), V(-0.02f, 0.9f), C(1052688u));
			});
			P("South Korea", delegate(Color32[] px, int W, int H)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_008b: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.5f, 0.17f, C(13446714u));
				for (int i = H / 2; i < H; i++)
				{
					for (int j = 0; j < W; j++)
					{
						float num = ((float)j + 0.5f) / (float)W;
						float num2 = ((float)i + 0.5f) / (float)H * 1.5f;
						if ((num - 0.5f) * (num - 0.5f) + (num2 - 0.75f) * (num2 - 0.75f) <= 0.028900001f)
						{
							Set(px, W, H, j, i, C(18336u));
						}
					}
				}
			});
			P("South Sudan", delegate(Color32[] px, int W, int H)
			{
				//IL_0037: 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_0055: 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_0085: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 1052688u, 16777215u, 14291482u, 16777215u, 493872u }, new float[5] { 4f, 1f, 4f, 1f, 4f });
				Tri(px, W, H, V(0f, 0f), V(0.4f, 0.5f), V(0f, 1f), C(1001391u));
				Star(px, W, H, 0.13f, 0.5f, 0.055f, 0f, C(16571657u));
			});
			P("Spain", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[3] { 11146523u, 15843072u, 11146523u }, new float[3] { 1f, 2f, 1f });
			});
			P("Sri Lanka", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: 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_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: 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)
				Fill(px, W, H, C(16758528u));
				Band(px, W, H, 0.05f, 0.07f, 0.95f, 0.93f, C(9246010u));
				Band(px, W, H, 0.05f, 0.07f, 0.2f, 0.93f, C(27455u));
				Band(px, W, H, 0.2f, 0.07f, 0.35f, 0.93f, C(16741120u));
				Disc(px, W, H, 0.64f, 0.5f, 0.08f, C(16758528u));
				Band(px, W, H, 0.56f, 0.3f, 0.585f, 0.62f, C(16758528u));
				Disc(px, W, H, 0.43f, 0.13f, 0.028f, C(16758528u));
				Disc(px, W, H, 0.89f, 0.13f, 0.028f, C(16758528u));
				Disc(px, W, H, 0.43f, 0.87f, 0.028f, C(16758528u));
				Disc(px, W, H, 0.89f, 0.87f, 0.028f, C(16758528u));
			});
			P("Sudan", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 13766708u, 16777215u, 1052688u);
				Tri(px, W, H, V(0f, 0f), V(0.38f, 0.5f), V(0f, 1f), C(29225u));
			});
			P("Suriname", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 3636799u, 16777215u, 11799085u, 16777215u, 3636799u }, new float[5] { 2f, 1f, 4f, 1f, 2f });
				Star(px, W, H, 0.5f, 0.5f, 0.09f, 0f, C(15517725u));
			});
			P("Sweden", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				Fill(px, W, H, C(27303u));
				NordicCross(px, W, H, 0.14f, C(16698370u));
			});
			P("Switzerland", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_004f: 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)
				Fill(px, W, H, C(14297372u));
				Band(px, W, H, 0.435f, 11f / 30f, 0.565f, 19f / 30f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.3f, 0.45666668f, 0.7f, 0.54333335f, Color32.op_Implicit(Color.white));
			});
			P("Syria", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 31293u, 16777215u, 1052688u);
				Star(px, W, H, 0.28f, 0.5f, 0.04f, 0f, C(13504806u));
				Star(px, W, H, 0.5f, 0.5f, 0.04f, 0f, C(13504806u));
				Star(px, W, H, 0.72f, 0.5f, 0.04f, 0f, C(13504806u));
			});
			P("Taiwan", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(16646144u));
				Band(px, W, H, 0f, 0f, 0.5f, 0.34f, C(149u));
				Sun(px, W, H, 0.25f, 0.17f, 0.05f, 0.045f, 12, Color32.op_Implicit(Color.white));
			});
			P("Tajikistan", delegate(Color32[] px, int W, int H)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[3] { 13369344u, 16777215u, 26112u }, new float[3] { 2f, 3f, 2f });
				Band(px, W, H, 0.42f, 0.52f, 0.58f, 0.545f, C(16302848u));
				Tri(px, W, H, V(0.43f, 0.52f), V(0.47f, 0.52f), V(0.45f, 0.475f), C(16302848u));
				Tri(px, W, H, V(0.48f, 0.52f), V(0.52f, 0.52f), V(0.5f, 0.47f), C(16302848u));
				Tri(px, W, H, V(0.53f, 0.52f), V(0.57f, 0.52f), V(0.55f, 0.475f), C(16302848u));
				for (int i = 0; i < 7; i++)
				{
					Star(px, W, H, 0.35f + (float)i * 0.05f, 0.42f - Mathf.Sin((float)i / 6f * MathF.PI) * 0.025f, 0.016f, 0f, C(16302848u));
				}
			});
			P("Tanzania", delegate(Color32[] px, int W, int H)
			{
				//IL_000d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				Tri(px, W, H, V(0f, 0f), V(1f, 0f), V(0f, 1f), C(2012474u));
				Tri(px, W, H, V(1f, 0f), V(1f, 1f), V(0f, 1f), C(41949u));
				DiagBand(px, W, H, rising: true, 0f, 0.13f, C(16568598u));
				DiagBand(px, W, H, rising: true, 0f, 0.095f, C(1052688u));
			});
			P("Thailand", delegate(Color32[] px, int W, int H)
			{
				HStripesW(px, W, H, new uint[5] { 10819889u, 16777215u, 2959946u, 16777215u, 10819889u }, new float[5] { 1f, 1f, 2f, 1f, 1f });
			});
			P("Timor-Leste", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				Fill(px, W, H, C(14427167u));
				Tri(px, W, H, V(0f, 0f), V(0.55f, 0.5f), V(0f, 1f), C(16762662u));
				Tri(px, W, H, V(0f, 0.14f), V(0.38f, 0.5f), V(0f, 0.86f), C(1052688u));
				Star(px, W, H, 0.14f, 0.5f, 0.06f, 15f, Color32.op_Implicit(Color.white));
			});
			P("Togo", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 27214u, 16764416u, 27214u, 16764416u, 27214u);
				Band(px, W, H, 0f, 0f, 0.42f, 0.6f, C(13766708u));
				Star(px, W, H, 0.21f, 0.3f, 0.1f, 0f, Color32.op_Implicit(Color.white));
			});
			P("Tonga", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				//IL_0054: 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)
				Fill(px, W, H, C(12648448u));
				Band(px, W, H, 0f, 0f, 0.4f, 0.34f, Color32.op_Implicit(Color.white));
				Band(px, W, H, 0.16f, 0.06f, 0.24f, 0.28f, C(12648448u));
				Band(px, W, H, 0.08f, 0.13f, 0.32f, 0.21f, C(12648448u));
			});
			P("Trinidad & Tobago", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: 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)
				Fill(px, W, H, C(14680064u));
				DiagBand(px, W, H, rising: false, 0f, 0.115f, Color32.op_Implicit(Color.white));
				DiagBand(px, W, H, rising: false, 0f, 0.085f, C(1052688u));
			});
			P("Tunisia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: 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_0054: 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)
				Fill(px, W, H, C(15138835u));
				Disc(px, W, H, 0.5f, 0.5f, 0.15f, Color32.op_Implicit(Color.white));
				Crescent(px, W, H, 0.49f, 0.5f, 0.11f, 0.04f, 0.095f, C(15138835u));
				Star(px, W, H, 0.555f, 0.5f, 0.05f, 90f, C(15138835u));
			});
			P("Turkey", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//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)
				Fill(px, W, H, C(14879255u));
				Crescent(px, W, H, 0.42f, 0.5f, 0.16f, 0.05f, 0.13f, Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.62f, 0.5f, 0.07f, 90f, Color32.op_Implicit(Color.white));
			});
			P("Turkmenistan", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: 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_0094: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
				Fill(px, W, H, C(33853u));
				Band(px, W, H, 0.08f, 0f, 0.24f, 1f, C(13772336u));
				for (int i = 0; i < 5; i++)
				{
					Rhomb(px, W, H, 0.16f, 0.1f + (float)i * 0.2f, 0.055f, 0.055f, Color32.op_Implicit(Color.white));
				}
				Crescent(px, W, H, 0.52f, 0.2f, 0.07f, 0.025f, 0.06f, Color32.op_Implicit(Color.white));
				for (int j = 0; j < 5; j++)
				{
					Star(px, W, H, 0.64f + (float)(j % 2) * 0.08f, 0.12f + (float)j * 0.05f, 0.02f, 0f, Color32.op_Implicit(Color.white));
				}
			});
			P("Tuvalu", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: 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_0138: 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)
				Fill(px, W, H, C(6730472u));
				Star(px, W, H, 0.62f, 0.3f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.76f, 0.24f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.88f, 0.33f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.66f, 0.48f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.8f, 0.5f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.9f, 0.58f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.62f, 0.66f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.75f, 0.7f, 0.035f, 0f, C(16764416u));
				Star(px, W, H, 0.87f, 0.78f, 0.035f, 0f, C(16764416u));
				PaintUnionJackCanton(px, W, H);
			});
			P("Uganda", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 1052688u, 16571396u, 14221312u, 1052688u, 16571396u, 14221312u);
				Disc(px, W, H, 0.5f, 0.5f, 0.11f, Color32.op_Implicit(Color.white));
				Disc(px, W, H, 0.5f, 0.52f, 0.05f, C(10266268u));
				Disc(px, W, H, 0.5f, 0.44f, 0.018f, C(14221312u));
			});
			P("Ukraine", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 22455u, 16766720u);
			});
			P("United Arab Emirates", delegate(Color32[] px, int W, int H)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 29487u, 16777215u, 1052688u);
				Band(px, W, H, 0f, 0f, 0.3f, 1f, C(16711680u));
			});
			P("United Kingdom", UnionJack);
			P("United States", delegate(Color32[] px, int W, int H)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 11674164u, 16777215u, 11674164u, 16777215u, 11674164u, 16777215u, 11674164u, 16777215u, 11674164u, 16777215u, 11674164u, 16777215u, 11674164u);
				Band(px, W, H, 0f, 0f, 0.46f, 0.53846157f, C(3947374u));
				for (int i = 0; i < 5; i++)
				{
					for (int j = 0; j < 4; j++)
					{
						Disc(px, W, H, 0.06f + (float)j * 0.11f + (float)(i % 2) * 0.055f, 0.055f + (float)i * 0.095f, 0.014f, Color32.op_Implicit(Color.white));
					}
				}
			});
			P("Uruguay", delegate(Color32[] px, int W, int H)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 16777215u, 14504u, 16777215u, 14504u, 16777215u, 14504u, 16777215u, 14504u, 16777215u);
				Band(px, W, H, 0f, 0f, 0.5f, 4f / 9f, Color32.op_Implicit(Color.white));
				Sun(px, W, H, 0.25f, 0.22f, 0.08f, 0.05f, 16, C(16568598u));
			});
			P("Uzbekistan", delegate(Color32[] px, int W, int H)
			{
				//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_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				HStripesW(px, W, H, new uint[5] { 39349u, 13504806u, 16777215u, 13504806u, 2012474u }, new float[5] { 8f, 1f, 8f, 1f, 8f });
				Crescent(px, W, H, 0.15f, 0.14f, 0.07f, 0.025f, 0.06f, Color32.op_Implicit(Color.white));
				for (int i = 0; i < 3; i++)
				{
					for (int j = 0; j < 3 + i; j++)
					{
						Disc(px, W, H, 0.52f - (float)j * 0.07f, 0.06f + (float)i * 0.075f, 0.016f, Color32.op_Implicit(Color.white));
					}
				}
			});
			P("Vanuatu", delegate(Color32[] px, int W, int H)
			{
				//IL_001c: 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_0068: 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_008e: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: 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_00eb: 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_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: 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)
				Band(px, W, H, 0f, 0f, 1f, 0.5f, C(13766708u));
				Band(px, W, H, 0f, 0.5f, 1f, 1f, C(38211u));
				Band(px, W, H, 0.3f, 0.46f, 1f, 0.54f, C(16633362u));
				Quad(px, W, H, V(0f, 0f), V(0.44f, 0.44f), V(0.44f, 0.54f), V(0f, 0.1f), C(16633362u));
				Quad(px, W, H, V(0f, 1f), V(0.44f, 0.56f), V(0.44f, 0.46f), V(0f, 0.9f), C(16633362u));
				Tri(px, W, H, V(0f, 0.1f), V(0.38f, 0.5f), V(0f, 0.9f), C(1052688u));
			});
			P("Vatican City", delegate(Color32[] px, int W, int H)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: 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_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				VStripes(px, W, H, 16769024u, 16777215u);
				Quad(px, W, H, V(0.66f, 0.4f), V(0.84f, 0.58f), V(0.82f, 0.61f), V(0.64f, 0.43f), C(10329500u));
				Quad(px, W, H, V(0.84f, 0.4f), V(0.66f, 0.58f), V(0.68f, 0.61f), V(0.86f, 0.43f), C(12620544u));
				Disc(px, W, H, 0.75f, 0.37f, 0.035f, C(13766708u));
			});
			P("Venezuela", delegate(Color32[] px, int W, int H)
			{
				//IL_0063: 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)
				HStripes(px, W, H, 16763904u, 9341u, 13571115u);
				for (int i = 0; i < 8; i++)
				{
					float num = (200f - (float)i * 28.5f) * (MathF.PI / 180f);
					Star(px, W, H, 0.5f + 0.14f * Mathf.Cos(num), 0.5f - 7f / 75f * Mathf.Sin(num), 0.022f, 0f, Color32.op_Implicit(Color.white));
				}
			});
			P("Vietnam", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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)
				Fill(px, W, H, C(14296349u));
				Star(px, W, H, 0.5f, 0.5f, 0.16f, 0f, C(16776960u));
			});
			P("Yemen", delegate(Color32[] px, int W, int H)
			{
				HStripes(px, W, H, 13504806u, 16777215u, 1052688u);
			});
			P("Zambia", delegate(Color32[] px, int W, int H)
			{
				//IL_0008: 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_0054: 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_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: 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)
				Fill(px, W, H, C(1673728u));
				Band(px, W, H, 0.55f, 0.55f, 0.7f, 1f, C(14557200u));
				Band(px, W, H, 0.7f, 0.55f, 0.85f, 1f, C(1052688u));
				Band(px, W, H, 0.85f, 0.55f, 1f, 1f, C(15695104u));
				Disc(px, W, H, 0.775f, 0.4f, 0.05f, C(15695104u));
				Tri(px, W, H, V(0.67f, 0.38f), V(0.88f, 0.31f), V(0.775f, 0.44f), C(15695104u));
			});
			P("Zimbabwe", delegate(Color32[] px, int W, int H)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				HStripes(px, W, H, 3248648u, 16765440u, 14557200u, 1052688u, 14557200u, 16765440u, 3248648u);
				Tri(px, W, H, V(0f, -0.02f), V(0.42f, 0.5f), V(0f, 1.02f), C(1052688u));
				Tri(px, W, H, V(0f, 0.03f), V(0.38f, 0.5f), V(0f, 0.97f), Color32.op_Implicit(Color.white));
				Star(px, W, H, 0.13f, 0.5f, 0.07f, 0f, C(14557200u));
				Disc(px, W, H, 0.13f, 0.5f, 0.028f, C(16765440u));
			});
			void P(string name, Action<Color32[], int, int> paint)
			{
				t.Add(new Def
				{
					name = name,
					cat = BgCat.Flag,
					paint = paint
				});
			}
			static Vector2 V(float u, float v)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return new Vector2(u, v);
			}
		}
	}
	internal enum BgCat : byte
	{
		Plain,
		Pattern,
		Pride,
		Flag
	}
	internal enum LiveSkin : byte
	{
		None,
		Void,
		Flame
	}
	internal static class CarveClass
	{
		private struct Frag
		{
			public readonly string fragment;

			public readonly int cls;

			public Frag(string fragment, int cls)
			{
				this.fragment = fragment;
				this.cls = cls;
			}
		}

		public const int Count = 8;

		public const int Earth = 0;

		public const int Stone = 1;

		public const int Metal = 2;

		public const int Crystal = 3;

		public const int Ice = 4;

		public const int Wood = 5;

		public const int Sand = 6;

		public const int Lava = 7;

		private static readonly string[] Names = new string[8] { "earth", "stone", "metal", "crystal", "ice", "wood", "sand", "lava" };

		private static readonly Frag[] Table = new Frag[25]
		{
			new Frag("metal", 2),
			new Frag("iron", 2),
			new Frag("pipe", 2),
			new Frag("grate", 2),
			new Frag("crystal", 3),
			new Frag("ice", 4),
			new Frag("snow", 4),
			new Frag("concrete", 1),
			new Frag("rock", 1),
			new Frag("stone", 1),
			new Frag("boulder", 1),
			new Frag("cliff", 1),
			new Frag("ruins", 1),
			new Frag("temple", 1),
			new Frag("column", 1),
			new Frag("pillar", 1),
			new Frag("brick", 1),
			new Frag("statue", 1),
			new Frag("root", 5),
			new Frag("wood", 5),
			new Frag("lava", 7),
			new Frag("coral", 6),
			new Frag("sand", 6),
			new Frag("dirt", 0),
			new Frag("grass", 0)
		};

		public static string Name(int cls)
		{
			if (cls < 0 || cls >= 8)
			{
				return "?";
			}
			return Names[cls];
		}

		public static int Of(Material mat)
		{
			string text = (((Object)(object)mat != (Object)null) ? ((Object)mat).name : null);
			if (string.IsNullOrEmpty(text))
			{
				return 0;
			}
			Frag[] table = Table;
			for (int i = 0; i < table.Length; i++)
			{
				Frag frag = table[i];
				if (text.IndexOf(frag.fragment, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return frag.cls;
				}
			}
			return 0;
		}
	}
	internal static class CarveStats
	{
		private static readonly Dictionary<uint, float> runTotal = new Dictionary<uint, float>();

		private static readonly Dictionary<uint, float> stage = new Dictionary<uint, float>();

		private static readonly Dictionary<uint, float> lastStage = new Dictionary<uint, float>();

		private static readonly Dictionary<uint, float[]> runClasses = new Dictionary<uint, float[]>();

		private static readonly float[] EmptyClasses = new float[8];

		public static void Add(uint userNetId, float m3)
		{
			if (userNetId != 0 && !(m3 <= 0f))
			{
				runTotal.TryGetValue(userNetId, out var value);
				runTotal[userNetId] = value + m3;
				stage.TryGetValue(userNetId, out var value2);
				stage[userNetId] = value2 + m3;
			}
		}

		public static void AddMaterial(uint userNetId, int cls, float m3)
		{
			if (userNetId != 0 && !(m3 <= 0f))
			{
				if (cls < 0 || cls >= 8)
				{
					cls = 0;
				}
				if (!runClasses.TryGetValue(userNetId, out var value))
				{
					value = (runClasses[userNetId] = new float[8]);
				}
				value[cls] += m3;
			}
		}

		public static float[] GetRunClasses(uint userNetId)
		{
			if (!runClasses.TryGetValue(userNetId, out var value))
			{
				return EmptyClasses;
			}
			return value;
		}

		public static float GetRun(uint userNetId)
		{
			if (!runTotal.TryGetValue(userNetId, out var value))
			{
				return 0f;
			}
			return value;
		}

		public static float GetLastStage(uint userNetId)
		{
			if (!lastStage.TryGetValue(userNetId, out var value))
			{
				return 0f;
			}
			return value;
		}

		public static void OnStageAdvance()
		{
			lastStage.Clear();
			foreach (KeyValuePair<uint, float> item in stage)
			{
				lastStage[item.Key] = item.Value;
			}
			stage.Clear();
		}

		public static void ResetRun()
		{
			runTotal.Clear();
			stage.Clear();
			lastStage.Clear();
			runClasses.Clear();
		}
	}
	internal class RosterEntry
	{
		public uint userNetId;

		public bool ready;

		public byte progress;

		public uint kills;

		public ulong damage;

		public ulong gold;

		public float m3Stage;

		public float m3Run;

		public double m3Ever;

		public byte[] matShare;

		public int nameFx = -1;

		public int title = -1;

		public bool titleNew;

		public int bg;

		public int runnerBest;

		public double wormsDug;

		public int prefA = -1;

		public int prefB = -1;

		public int prefC = -1;
	}
	internal static class LoadingRoster
	{
		public static readonly List<RosterEntry> Entries = new List<RosterEntry>();

		public static bool AllReady;

		public static float LastSyncTime;

		public static RosterEntry Find(uint userNetId)
		{
			for (int i = 0; i < Entries.Count; i++)
			{
				if (Entries[i].userNetId == userNetId)
				{
					return Entries[i];
				}
			}
			return null;
		}

		public static void Clear()
		{
			Entries.Clear();
			AllReady = false;
			LastSyncTime = 0f;
		}
	}
	internal static class LoadingOverlay
	{
		private struct RimTier
		{
			public string name;

			public double min;

			public Color col;
		}

		private class PlayerCard
		{
			public uint userNetId;

			public GameObject go;

			public float width;

			public RawImage portrait;

			public RawImage cardBackground;

			public Image cardScrim;

			public int cardBackgroundIdx = -1;

			public Image rim;

			public Color rimBase;

			public bool rimShimmer;

			public Image crown;

			public RectTransform crownRect;

			public UiKit.Label name;

			public UiKit.Label title;

			public UiKit.Label status;

			public UiMeter statusBar;

			public Image accent;

			public Image border;

			public UiKit.Label[] statValues;

			public Image[] colorPicks;

			public int statusPct = -1;
		}

		private class ReelView
		{
			public LootReel reel;

			public GameObject root;

			public CanvasGroup group;

			public RectTransform content;

			public UiKit.Label caption;

			public Image marker;

			public Image landFrame;

			public Image flash;

			public RectTransform wonTile;

			public float stride;

			public float pStart;

			public float pEnd;

			public float spawnedAt;

			public float showT0;

			public int ticksPlayed;

			public bool startSoundPlayed;

			public bool landed;

			public float landedAt;

			public List<(UiKit.Label label, int fx)> fxTiles;
		}

		private sealed class ScreenState
		{
			public GameObject go;

			public UiMeter bar;

			public float wallScale = 1f;

			public float wallBottom = -180f;

			public bool multiRowWall;

			public bool needCardRebuild;

			public UiKit.Label label;

			public string lastLabelPhase;

			public int lastLabelA = -1;

			public int lastLabelB = -1;

			public UiKit.Label tipText;

			public RectTransform cardRow;

			public readonly List<PlayerCard> cards = new List<PlayerCard>();

			public int[] tipOrder;

			public float shownAt;

			public int lastTipIdx = -1;

			public readonly Dictionary<(uint netId, byte seq), ReelView> reelViews = new Dictionary<(uint, byte), ReelView>();

			public readonly HashSet<(uint netId, byte seq)> reelsSkipped = new HashSet<(uint, byte)>();

			public readonly HashSet<(uint netId, byte seq)> reelsSettled = new HashSet<(uint, byte)>();

			public readonly Dictionary<(uint netId, byte seq), float> reelsAwaitingCard = new Dictionary<(uint, byte), float>();

			public readonly Dictionary<(uint netId, byte seq), float> reelShowT0 = new Dictionary<(uint, byte), float>();

			public readonly Dictionary<(uint netId, byte kind, int idx), float> reelReportedAt = new Dictionary<(uint, byte, int), float>();

			public float reelLastTickAt;

			public float lastReelStartSoundAt;

			public float lastReelLandSoundAt;

			public float lastSeenSync = -1f;

			public float lastHeavyRefresh;
		}

		private static readonly List<NetworkUser> aliveScratch = new List<NetworkUser>();

		private static readonly List<int> orderScratch = new List<int>();

		private static int[] rankScratch = new int[8];

		private static readonly int[] prefScratch = new int[3];

		private static readonly Comparison<int> RankComparison = delegate(int a, int b)
		{
			int num = K(b).CompareTo(K(a));
			if (num != 0)
			{
				return num;
			}
			num = D(b).CompareTo(D(a));
			if (num != 0)
			{
				return num;
			}
			num = M(b).CompareTo(M(a));
			return (num != 0) ? num : G(b).CompareTo(G(a));
		};

		private const float BarWidth = 720f;

		private const float CardHeight = 420f;

		private const float CardGap = 24f;

		private const float TipInterval = 6f;

		private static readonly Color ColBg = new Color(0.02f, 0.02f, 0.03f, 1f);

		private static readonly Color ColOrange = UiKit.AccentOrange;

		private static readonly Color ColGreen = UiKit.Green;

		private static readonly Color ColText = UiKit.TextPale;

		private static readonly Color ColDim = UiKit.TextDim;

		private static readonly Color ColGold = UiKit.Gold;

		private static readonly Color ColSilver = new Color(0.82f, 0.85f, 0.9f, 1f);

		private static readonly Color ColBronze = new Color(0.8f, 0.52f, 0.28f, 1f);

		private static readonly Color ColTitle = new Color(0.84f, 0.73f, 0.52f, 1f);

		private static readonly RimTier[] RimTiers = new RimTier[5]
		{
			new RimTier
			{
				name = "Wood",
				min = 0.0,
				col = new Color(0.44f, 0.29f, 0.15f, 1f)
			},
			new RimTier
			{
				name = "Bronze",
				min = 1000000.0,
				col = new Color(0.83f, 0.53f, 0.26f, 1f)
			},
			new RimTier
			{
				name = "Silver",
				min = 10000000.0,
				col = new Color(0.8f, 0.83f, 0.88f, 1f)
			},
			new RimTier
			{
				name = "Gold",
				min = 100000000.0,
				col = new Color(1f, 0.83f, 0.35f, 1f)
			},
			new RimTier
			{
				name = "Platinum",
				min = 1000000000.0,
				col = new Color(0.66f, 0.93f, 0.98f, 1f)
			}
		};

		private static readonly string[] Tips = BuildTips();

		private static ScreenState screen;

		private static Sprite crownSprite;

		private static readonly List<(uint netId, byte seq)> reelPruneScratch = new List<(uint, byte)>();

		private static readonly string[] StatLabels = new string[8] { "Kills", "Damage", "Gold", "Carved lvl", "Carved run", "Carved ever", "Best run", "Worms dug" };

		private static readonly int[] StatGridOrder = new int[8] { 0, 3, 1, 4, 2, 5, 6, 7 };

		private const float OrphanReelGraceSeconds = 3f;

		private const float ReportStaleSeconds = 6f;

		private static Sprite edgeFadeSprite;

		internal static bool ScreenAlive => screen != null;

		internal static float WallBottom => screen?.wallBottom ?? (-180f);

		internal static bool MultiRowWall
		{
			get
			{
				if (screen != null)
				{
					return screen.multiRowWall;
				}
				return false;
			}
		}

		internal static bool AnyReelAwaitingShow
		{
			get
			{
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				ScreenState screenState = screen;
				if (screenState == null)
				{
					return false;
				}
				foreach (LootReel reel in LootReveal.Reels)
				{
					(uint, byte) item = (reel.userNetId, reel.seq);
					if (!screenState.reelsSkipped.Contains(item) && !screenState.reelsSettled.Contains(item))
					{
						return true;
					}
				}
				if (!ArcadeHost.CeremonyClosed)
				{
					foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
					{
						if ((Object)(object)readOnlyInstances == (Object)null || !((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
						{
							continue;
						}
						string text = UserLifetimeStats.ProfileKey(readOnlyInstances);
						if (text != null && UserLifetimeStats.TryPeekPending(text, out var kind, out var idx))
						{
							Dictionary<(uint netId, byte kind, int idx), float> reelReportedAt = screenState.reelReportedAt;
							NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
							if (!reelReportedAt.TryGetValue((((NetworkInstanceId)(ref netId)).Value, kind, idx), out var value) || Time.unscaledTime - value < 6f)
							{
								return true;
							}
						}
					}
				}
				return false;
			}
		}

		internal static bool AnyReelLive
		{
			get
			{
				if (screen != null)
				{
					return screen.reelViews.Count > 0;
				}
				return false;
			}
		}

		private static uint K(int i)
		{
			//IL_000b: 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)
			NetworkInstanceId netId = ((NetworkBehaviour)aliveScratch[i]).netId;
			return LoadingRoster.Find(((NetworkInstanceId)(ref netId)).Value)?.kills ?? 0;
		}

		private static ulong D(int i)
		{
			//IL_000b: 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)
			NetworkInstanceId netId = ((NetworkBehaviour)aliveScratch[i]).netId;
			return LoadingRoster.Find(((NetworkInstanceId)(ref netId)).Value)?.damage ?? 0;
		}

		private static float M(int i)
		{
			//IL_000b: 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)
			NetworkInstanceId netId = ((NetworkBehaviour)aliveScratch[i]).netId;
			return LoadingRoster.Find(((NetworkInstanceId)(ref netId)).Value)?.m3Run ?? 0f;
		}

		private static ulong G(int i)
		{
			//IL_000b: 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)
			NetworkInstanceId netId = ((NetworkBehaviour)aliveScratch[i]).netId;
			return LoadingRoster.Find(((NetworkInstanceId)(ref netId)).Value)?.gold ?? 0;
		}

		private static void RefreshCards(ScreenState state)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: 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_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0754: Unknown result type (might be due to invalid IL or missing references)
			//IL_0759: Unknown result type (might be due to invalid IL or missing references)
			//IL_0713: Unknown result type (might be due to invalid IL or missing references)
			//IL_070c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0705: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07af: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_095f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0964: Unknown result type (might be due to invalid IL or missing references)
			//IL_096e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)state.cardRow == (Object)null)
			{
				return;
			}
			ReadOnlyCollection<NetworkUser> readOnlyInstancesList = NetworkUser.readOnlyInstancesList;
			List<NetworkUser> list = aliveScratch;
			list.Clear();
			foreach (NetworkUser item in readOnlyInstancesList)
			{
				if ((Object)(object)item != (Object)null)
				{
					list.Add(item);
				}
			}
			List<PlayerCard> cards = state.cards;
			bool flag = list.Count != cards.Count;
			NetworkInstanceId netId;
			if (!flag)
			{
				for (int i = 0; i < list.Count; i++)
				{
					uint userNetId = cards[i].userNetId;
					netId = ((NetworkBehaviour)list[i]).netId;
					if (userNetId != ((NetworkInstanceId)(ref netId)).Value)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag && state.needCardRebuild && Mathf.CeilToInt((float)list.Count / 4f) > 1)
			{
				flag = true;
			}
			state.needCardRebuild = false;
			if (flag)
			{
				BuildCards(state, list);
			}
			if (cards.Count == 0)
			{
				return;
			}
			for (int j = 0; j < cards.Count; j++)
			{
				PlayerCard playerCard = cards[j];
				NetworkUser val = list[j];
				RosterEntry rosterEntry = LoadingRoster.Find(playerCard.userNetId);
				if ((Object)(object)playerCard.portrait != (Object)null && (Object)(object)playerCard.portrait.texture == (Object)null)
				{
					Texture val2 = ResolvePortrait(val);
					if ((Object)(object)val2 != (Object)null)
					{
						playerCard.portrait.texture = val2;
						((Graphic)playerCard.portrait).color = Color.white;
					}
				}
				if (playerCard.name != null)
				{
					playerCard.name.Text = (string.IsNullOrEmpty(val.userName) ? $"Player {j + 1}" : val.userName);
					playerCard.name.Color = (((NetworkBehaviour)val).isLocalPlayer ? ColOrange : ColText);
					int fx = (((NetworkBehaviour)val).isLocalPlayer ? UserLifetimeStats.EffectiveNameFx(UserLifetimeStats.ProfileKey(val)) : (rosterEntry?.nameFx ?? (-1)));
					UiKit.Label name = playerCard.name;
					netId = ((NetworkBehaviour)val).netId;
					NameFxSystem.Animate(name, fx, ((NetworkInstanceId)(ref netId)).Value * 2654435761u, Time.unscaledTime);
				}
				bool ready = rosterEntry?.ready ?? false;
				if (((NetworkBehaviour)val).isLocalPlayer && VoxelTerrainManager.LocalConversionDone)
				{
					ready = true;
				}
				UpdateStatus(playerCard, ((NetworkBehaviour)val).isLocalPlayer, ready, rosterEntry?.progress ?? 0);
				if ((Object)(object)playerCard.cardBackground != (Object)null && playerCard.cardBackgroundIdx > 0 && playerCard.cardBackgroundIdx < BackgroundSystem.Table.Length)
				{
					BackgroundSystem.MarkAnimatedVisible(playerCard.cardBackgroundIdx);
					BackgroundSystem.Def def = BackgroundSystem.Table[playerCard.cardBackgroundIdx];
					if (def.live != LiveSkin.None)
					{
						Texture val3 = TerrariumSkins.TryGetCardSkin((int)def.live);
						if ((Object)(object)val3 == (Object)null)
						{
							val3 = (Texture)(object)BackgroundSystem.GetTexture(playerCard.cardBackgroundIdx);
						}
						if ((Object)(object)playerCard.cardBackground.texture != (Object)(object)val3)
						{
							playerCard.cardBackground.texture = val3;
						}
					}
				}
				if (playerCard.rimShimmer && (Object)(object)playerCard.rim != (Object)null)
				{
					((Graphic)playerCard.rim).color = Color.Lerp(playerCard.rimBase, Color.white, 0.1f + 0.1f * Mathf.Sin(Time.unscaledTime * 2.3f + (float)playerCard.userNetId * 0.61f));
				}
			}
			if (!flag && LoadingRoster.LastSyncTime == state.lastSeenSync && state.reelViews.Count <= 0 && !(Time.unscaledTime - state.lastHeavyRefresh > 0.5f))
			{
				return;
			}
			state.lastSeenSync = LoadingRoster.LastSyncTime;
			state.lastHeavyRefresh = Time.unscaledTime;
			List<int> list2 = orderScratch;
			list2.Clear();
			for (int k = 0; k < list.Count; k++)
			{
				list2.Add(k);
			}
			list2.Sort(RankComparison);
			if (rankScratch.Length < list.Count)
			{
				rankScratch = new int[list.Count * 2];
			}
			int[] array = rankScratch;
			for (int l = 0; l < list2.Count; l++)
			{
				array[list2[l]] = l;
			}
			uint num = 0u;
			ulong num2 = 0uL;
			ulong num3 = 0uL;
			float num4 = 0f;
			float num5 = 0f;
			foreach (NetworkUser item2 in list)
			{
				netId = ((NetworkBehaviour)item2).netId;
				RosterEntry rosterEntry2 = LoadingRoster.Find(((NetworkInstanceId)(ref netId)).Value);
				if (rosterEntry2 != null)
				{
					if (rosterEntry2.kills > num)
					{
						num = rosterEntry2.kills;
					}
					if (rosterEntry2.damage > num2)
					{
						num2 = rosterEntry2.damage;
					}
					if (rosterEntry2.gold > num3)
					{
						num3 = rosterEntry2.gold;
					}
					if (rosterEntry2.m3Stage > num4)
					{
						num4 = rosterEntry2.m3Stage;
					}
					if (rosterEntry2.m3Run > num5)
					{
						num5 = rosterEntry2.m3Run;
					}
				}
			}
			for (int m = 0; m < cards.Count; m++)
			{
				PlayerCard playerCard2 = cards[m];
				NetworkUser val4 = list[m];
				RosterEntry rosterEntry3 = LoadingRoster.Find(playerCard2.userNetId);
				int num6 = rosterEntry3?.bg ?? (((NetworkBehaviour)val4).isLocalPlayer ? BackgroundSystem.CurrentBackground(val4) : 0);
				if (num6 != playerCard2.cardBackgroundIdx && (Object)(object)playerCard2.cardBackground != (Object)null)
				{
					playerCard2.cardBackgroundIdx = num6;
					Texture2D texture = BackgroundSystem.GetTexture(num6);
					playerCard2.cardBackground.texture = (Texture)(object)texture;
					((Behaviour)playerCard2.cardBackground).enabled = (Object)(object)texture != (Object)null;
					if ((Object)(object)playerCard2.cardScrim != (Object)null)
					{
						((Behaviour)playerCard2.cardScrim).enabled = (Object)(object)texture != (Object)null;
					}
				}
				if (playerCard2.title != null)
				{
					int num7 = rosterEntry3?.title ?? (((NetworkBehaviour)val4).isLocalPlayer ? TitleSystem.CurrentTitle(val4) : (-1));
					bool flag2 = rosterEntry3?.titleNew ?? (((NetworkBehaviour)val4).isLocalPlayer && TitleSystem.IsFresh(playerCard2.userNetId));
					string text = ((num7 >= 0 && num7 < TitleSystem.Table.Length) ? TitleSystem.Table[num7] : "");
					if (flag2 && text.Length > 0)
					{
						text = "NEW!  " + text;
					}
					playerCard2.title.Text = text;
					playerCard2.title.Color = (flag2 ? ColGold : ColTitle);
				}
				bool flag3 = array[m] < 3 && cards.Count > 1 && (K(m) != 0 || D(m) != 0 || M(m) > 0f || G(m) != 0);
				if ((Object)(object)playerCard2.crown != (Object)null)
				{
					((Behaviour)playerCard2.crown).enabled = flag3;
					if (flag3)
					{
						((Graphic)playerCard2.crown).color = ((array[m] == 0) ? ColGold : ((array[m] == 1) ? ColSilver : ColBronze));
					}
				}
				double num8 = rosterEntry3?.m3Ever ?? (((NetworkBehaviour)val4).isLocalPlayer ? UserLifetimeStats.GetRunBase(val4) : 0.0);
				RimTier rimTier = TierFor(num8);
				playerCard2.rimBase = rimTier.col;
				playerCard2.rimShimmer = rimTier.min >= RimTiers[RimTiers.Length - 1].min;
				if ((Object)(object)playerCard2.rim != (Object)null && !playerCard2.rimShimmer && ((Graphic)playerCard2.rim).color != rimTier.col)
				{
					((Graphic)playerCard2.rim).color = rimTier.col;
				}
				if (playerCard2.statValues == null)
				{
					continue;
				}
				SetStat(playerCard2.statValues[0], (rosterEntry3 == null) ? "—" : rosterEntry3.kills.ToString(), rosterEntry3 != null && rosterEntry3.kills != 0 && rosterEntry3.kills == num);
				SetStat(playerCard2.statValues[1], (rosterEntry3 == null) ? "—" : Compact(rosterEntry3.damage), rosterEntry3 != null && rosterEntry3.damage != 0 && rosterEntry3.damage == num2);
				SetStat(playerCard2.statValues[2], (rosterEntry3 == null) ? "—" : Compact(rosterEntry3.gold), rosterEntry3 != null && rosterEntry3.gold != 0 && rosterEntry3.gold == num3);
				SetStat(playerCard2.statValues[3], (rosterEntry3 == null) ? "—" : Cubic(rosterEntry3.m3Stage), rosterEntry3 != null && rosterEntry3.m3Stage > 0f && rosterEntry3.m3Stage == num4);
				SetStat(playerCard2.statValues[4], (rosterEntry3 == null) ? "—" : Cubic(rosterEntry3.m3Run), rosterEntry3 != null && rosterEntry3.m3Run > 0f && rosterEntry3.m3Run == num5);
				playerCard2.statValues[5].Text = ((rosterEntry3 == null && !((NetworkBehaviour)val4).isLocalPlayer) ? "—" : Cubic(num8));
				playerCard2.statValues[5].Color = Color.Lerp(rimTier.col, Color.white, 0.3f);
				int num9;
				double num10;
				int num11;
				int num12;
				int num13;
				if (((NetworkBehaviour)val4).isLocalPlayer)
				{
					string profileKey = UserLifetimeStats.ProfileKey(val4);
					num9 = UserLifetimeStats.RunnerBest(profileKey);
					num10 = UserLifetimeStats.WormsDug(profileKey);
					IReadOnlyList<int> readOnlyList = UserLifetimeStats.ArcadeColors(profileKey);
					num11 = ((readOnlyList.Count > 0) ? readOnlyList[0] : (-1));
					num12 = ((readOnlyList.Count > 1) ? readOnlyList[1] : (-1));
					num13 = ((readOnlyList.Count > 2) ? readOnlyList[2] : (-1));
				}
				else
				{
					num9 = rosterEntry3?.runnerBest ?? 0;
					num10 = rosterEntry3?.wormsDug ?? 0.0;
					num11 = rosterEntry3?.prefA ?? (-1);
					num12 = rosterEntry3?.prefB ?? (-1);
					num13 = rosterEntry3?.prefC ?? (-1);
				}
				SetStat(playerCard2.statValues[6], (num9 > 0) ? num9.ToString() : "—", leader: false);
				SetStat(playerCard2.statValues[7], (num10 > 0.0) ? Compact((ulong)num10) : "—", leader: false);
				int[] array2 = prefScratch;
				array2[0] = num11;
				array2[1] = num12;
				array2[2] = num13;
				for (int n = 0; n < playerCard2.colorPicks.Length; n++)
				{
					Image val5 = playerCard2.colorPicks[n];
					if ((Object)(object)val5 == (Object)null)
					{
						continue;
					}
					if (array2[n] < 0)
					{
						((Behaviour)val5).enabled = false;
						continue;
					}
					if (CommandoSprites.Ready)
					{
						val5.sprite = CommandoSprites.CommandoFrame(array2[n], 0f);
						((Graphic)val5).color = Color.white;
					}
					else
					{
						val5.sprite = null;
						((Graphic)val5).color = CommandoSprites.Tint(array2[n]);
					}
					((Behaviour)val5).enabled = true;
				}
			}
		}

		private static void UpdateStatus(PlayerCard card, bool isLocal, bool ready, byte remotePct)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0070: 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_01c5: 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_01e3: 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_0130: Unknown result type (might be due to invalid IL or missing references)
			if (card.statusBar == null)
			{
				return;
			}
			if (ready)
			{
				((Graphic)card.statusBar.Fill).color = ColGreen;
				card.statusBar.SetFrac(1f);
				if (card.status != null)
				{
					card.status.Text = "READY";
					card.status.Color = ColGreen;
				}
				if ((Object)(object)card.accent != (Object)null)
				{
					((Graphic)card.accent).color = ColGreen;
				}
				if ((Object)(object)card.border != (Object)null)
				{
					((Graphic)card.border).color = new Color(0.35f, 0.62f, 0.35f, 0.85f);
				}
			}
			else if (isLocal || remotePct > 0)
			{
				float num = (isLocal ? ConvertProgress.Fraction() : ((float)(int)remotePct / 100f));
				((Graphic)card.statusBar.Fill).color = ColOrange;
				card.statusBar.SetFrac(num);
				if (card.status != null)
				{
					int num2 = (int)(num * 100f);
					if (num2 != card.statusPct)
					{
						card.statusPct = num2;
						card.status.Text = $"LOADING {num2}%";
					}
					card.status.Color = ColDim;
				}
				if ((Object)(object)card.accent != (Object)null)
				{
					((Graphic)card.accent).color = ColOrange;
				}
			}
			else
			{
				float t = Mathf.PingPong((Time.unscaledTime + (float)card.userNetId * 0.37f) * 0.7f, 1f);
				((Graphic)card.statusBar.Fill).color = ColOrange;
				card.statusBar.SetSweep(t, 0.3f);
				if (card.status != null)
				{
					card.status.Text = "LOADING";
					card.status.Color = ColDim;
				}
				if ((Object)(object)card.accent != (Object)null)
				{
					((Graphic)card.accent).color = ColOrange;
				}
			}
		}

		private static void SetStat(UiKit.Label t, string value, bool leader)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (t != null)
			{
				t.Text = value;
				t.Color = (leader ? ColGold : ColText);
			}
		}

		private static void BuildCards(ScreenState state, List<NetworkUser> users)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			//IL_021f: 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_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_0580: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fd: Expected O, but got Unknown
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0681: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_069f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0702: Unknown result type (might be due to invalid IL or missing references)
			//IL_0728: Unknown result type (might be due to invalid IL or missing references)
			//IL_0748: Unknown result type (might be due to invalid IL or missing references)
			//IL_0776: Unknown result type (might be due to invalid IL or missing references)
			//IL_079c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Unknown result type (might be due to invalid IL or missing references)
			//IL_083c: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08db: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_092e: Unknown result type (might be due to invalid IL or missing references)
			//IL_094c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0967: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b05: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerCard> cards = state.cards;
			foreach (PlayerCard item in cards)
			{
				if ((Object)(object)item.go != (Object)null)
				{
					Object.Destroy((Object)(object)item.go);
				}
			}
			cards.Clear();
			if (users.Count == 0)
			{
				return;
			}
			int count = users.Count;
			int num = Mathf.CeilToInt((float)count / 4f);
			int num2 = Mathf.CeilToInt((float)count / (float)num);
			state.cardRow.anchoredPosition = new Vector2(0f, (num > 1) ? 30f : 180f);
			float num3 = (float)num * 420f + (float)(num - 1) * 116f;
			float num4 = ((num > 1 && ArcadeHost.StripOpen) ? (876f - 2f * ArcadeHost.StripReserve) : 620f);
			state.wallScale = Mathf.Min(1f, num4 / num3);
			state.multiRowWall = num > 1;
			state.wallBottom = state.cardRow.anchoredPosition.y - num3 * 0.5f * state.wallScale;
			((Transform)state.cardRow).localScale = new Vector3(state.wallScale, state.wallScale, 1f);
			if (state.tipText != null)
			{
				state.tipText.Rect.anchoredPosition = (state.multiRowWall ? new Vector2(0f, 405f) : new Vector2(0f, -385f));
			}
			if ((Object)(object)crownSprite == (Object)null)
			{
				crownSprite = BuildCrownSprite();
			}
			for (int i = 0; i < count; i++)
			{
				NetworkUser val = users[i];
				PlayerCard playerCard = new PlayerCard();
				NetworkInstanceId netId = ((NetworkBehaviour)val).netId;
				playerCard.userNetId = ((NetworkInstanceId)(ref netId)).Value;
				playerCard.width = 280f;
				PlayerCard playerCard2 = playerCard;
				playerCard2.go = new GameObject($"card_{i}");
				playerCard2.go.transform.SetParent((Transform)(object)state.cardRow, false);
				RectTransform obj = playerCard2.go.AddComponent<RectTransform>();
				obj.sizeDelta = new Vector2(280f, 420f);
				int num5 = i / num2;
				int num6 = i % num2;
				int num7 = Mathf.Min(num2, count - num5 * num2);
				obj.anchoredPosition = new Vector2(((float)num6 - (float)(num7 - 1) * 0.5f) * 304f, num3 * 0.5f - 210f - (float)num5 * 536f);
				GameObject val2 = new GameObject("crown");
				val2.transform.SetParent(playerCard2.go.transform, false);
				playerCard2.crown = val2.AddComponent<Image>();
				playerCard2.crown.sprite = crownSprite;
				((Behaviour)playerCard2.crown).enabled = false;
				playerCard2.crownRect = ((Graphic)playerCard2.crown).rectTransform;
				float num8 = 140f;
				playerCard2.crownRect.sizeDelta = new Vector2(num8, num8 * 0.83f);
				playerCard2.crownRect.anchoredPosition = new Vector2(0f, 210f + num8 * 0.16f);
				((Transform)playerCard2.crownRect).localRotation = Quaternion.Euler(0f, 0f, 12f);
				Image val3 = UiKit.CreatePanel("cardFace", playerCard2.go.transform, new Color(0.075f, 0.075f, 0.095f, 1f));
				((Graphic)val3).rectTransform.sizeDelta = new Vector2(278f, 418f);
				playerCard2.cardBackground = UiKit.CreateMaskedCard("cardBackground", val3, null);
				((Graphic)playerCard2.cardBackground).color = new Color(0.62f, 0.62f, 0.62f, 1f);
				playerCard2.cardScrim = UiKit.CreateImage("cardScrim", ((Component)val3).transform, new Color(0.02f, 0.02f, 0.03f, 0.88f));
				playerCard2.cardScrim.sprite = UiKit.GradientScrim();
				playerCard2.cardScrim.type = (Type)0;
				((Graphic)playerCard2.cardScrim).rectTransform.anchorMin = new Vector2(0f, 0f);
				((Graphic)playerCard2.cardScrim).rectTransform.anchorMax = new Vector2(1f, 0f);
				((Graphic)playerCard2.cardScrim).rectTransform.pivot = new Vector2(0.5f, 0f);
				((Graphic)playerCard2.cardScrim).rectTransform.sizeDelta = new Vector2(0f, 300f);
				((Graphic)playerCard2.cardScrim).rectTransform.anchoredPosition = Vector2.zero;
				((Behaviour)playerCard2.cardScrim).enabled = false;
				playerCard2.accent = UiKit.CreateImage("accent", playerCard2.go.transform, ColOrange);
				((Graphic)playerCard2.accent).rectTransform.sizeDelta = new Vector2(270f, 4f);
				((Graphic)playerCard2.accent).rectTransform.anchoredPosition = new Vector2(0f, 205f);
				playerCard2.rim = UiKit.CreateImage("portraitRim", playerCard2.go.transform, RimTiers[0].col);
				((Graphic)playerCard2.rim).rectTransform.sizeDelta = new Vector2(158f, 158f);
				((Graphic)playerCard2.rim).rectTransform.anchoredPosition = new Vector2(0f, 115f);
				Image val4 = UiKit.CreateImage("portraitFrame", playerCard2.go.transform, new Color(0.03f, 0.03f, 0.045f, 1f));
				((Graphic)val4).rectTransform.sizeDelta = new Vector2(146f, 146f);
				((Graphic)val4).rectTransform.anchoredPosition = new Vector2(0f, 115f);
				GameObject val5 = new GameObject("portrait");
				val5.transform.SetParent(((Component)val4).transform, false);
				playerCard2.portrait = val5.AddComponent<RawImage>();
				((Graphic)playerCard2.portrait).rectTransform.sizeDelta = new Vector2(142f, 142f);
				((Graphic)playerCard2.portrait).color = new Color(1f, 1f, 1f, 0.06f);
				playerCard2.statusBar = new UiMeter("statusBarBg", playerCard2.go.transform, new Vector2(220f, 12f), new Color(0.14f, 0.14f, 0.17f, 1f), ColOrange, 2f);
				playerCard2.statusBar.Rect.anchoredPosition = new Vector2(0f, -26f);
				((Component)playerCard2.statusBar.Bg).gameObject.AddComponent<Canvas>();
				playerCard2.name = UiKit.CreateLabel("name", playerCard2.go.transform, 20f, ColText, (TextAnchor)4);
				playerCard2.name.Rect.sizeDelta = new Vector2(260f, 26f);
				playerCard2.name.Rect.anchoredPosition = new Vector2(0f, 18f);
				playerCard2.name.ClipSingleLine();
				playerCard2.title = UiKit.CreateLabel("title", playerCard2.go.transform, 14f, ColTitle, (TextAnchor)4);
				playerCard2.title.Rect.sizeDelta = new Vector2(264f, 17f);
				playerCard2.title.Rect.anchoredPosition = new Vector2(0f, -8f);
				playerCard2.title.Italic();
				playerCard2.title.ClipSingleLine();
				playerCard2.status = UiKit.CreateLabel("status", playerCard2.go.transform, 14f, ColDim, (TextAnchor)4);
				playerCard2.status.Rect.sizeDelta = new Vector2(264f, 20f);
				playerCard2.status.Rect.anchoredPosition = new Vector2(0f, -50f);
				playerCard2.statValues = new UiKit.Label[StatLabels.Length];
				for (int j = 0; j < StatGridOrder.Length; j++)
				{
					int num9 = StatGridOrder[j];
					float num10 = ((j % 2 == 0) ? (-1f) : 1f) * 280f * 0.25f;
					float num11 = -68f - 30f * (float)(j / 2);
					UiKit.Label label = UiKit.CreateLabel($"statLabel{num9}", playerCard2.go.transform, 11f, ColDim, (TextAnchor)4);
					label.Rect.sizeDelta = new Vector2(128.8f, 14f);
					label.Rect.anchoredPosition = new Vector2(num10, num11);
					label.ClipSingleLine();
					label.Text = StatLabels[num9];
					UiKit.Label label2 = UiKit.CreateLabel($"statValue{num9}", playerCard2.go.transform, 15f, ColText, (TextAnchor)4);
					label2.Rect.sizeDelta = new Vector2(128.8f, 18f);
					label2.Rect.anchoredPosition = new Vector2(num10, num11 - 14f);
					label2.ClipSingleLine();
					label2.Text = "—";
					playerCard2.statValues[num9] = label2;
				}
				UiKit.Label label3 = UiKit.CreateLabel("colorsLabel", playerCard2.go.transform, 11f, ColDim, (TextAnchor)4);
				label3.Rect.sizeDelta = new Vector2(128.8f, 14f);
				label3.Rect.anchoredPosition = new Vector2(-70f, -196f);
				label3.Text = "Colors";
				playerCard2.colorPicks = (Image[])(object)new Image[3];
				for (int k = 0; k < 3; k++)
				{
					GameObject val6 = new GameObject($"colorPick{k}");
					val6.transform.SetParent(playerCard2.go.transform, false);
					Image val7 = val6.AddComponent<Image>();
					((Graphic)val7).raycastTarget = false;
					((Graphic)val7).rectTransform.sizeDelta = new Vector2(12f, 22f);
					((Graphic)val7).rectTransform.anchoredPosition = new Vector2(70f + (float)(k - 1) * 18f, -196f);
					((Behaviour)val7).enabled = false;
					playerCard2.colorPicks[k] = val7;
				}
				playerCard2.border = UiKit.CreateOutline("border", playerCard2.go.transform, new Color(0.42f, 0.44f, 0.5f, 0.85f));
				((Graphic)playerCard2.border).rectTransform.sizeDelta = new Vector2(280f, 420f);
				cards.Add(playerCard2);
			}
		}

		private static Texture ResolvePortrait(NetworkUser nu)
		{
			GameObject val = (((Object)(object)nu != (Object)null && (Object)(object)nu.master != (Object)null) ? nu.master.bodyPrefab : null);
			CharacterBody val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<CharacterBody>() : null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return null;
			}
			return val2.portraitIcon;
		}

		private static RimTier TierFor(double m3Ever)
		{
			int num = RimTiers.Length - 1;
			while (num > 0 && m3Ever < RimTiers[num].min)
			{
				num--;
			}
			return RimTiers[num];
		}

		private static string[] BuildTips()
		{
			int num = 0;
			int num2 = 0;
			BackgroundSystem.Def[] table = BackgroundSystem.Table;
			for (int i = 0; i < table.Length; i++)
			{
				BackgroundSystem.Def def = table[i];
				if (def.cat == BgCat.Flag)
				{
					num++;
				}
				if (def.anim != null)
				{
					num2++;
				}
			}
			RimTier rimTier = RimTiers[RimTiers.Length - 1];
			string text = ((rimTier.min == 1000000000.0) ? "a billion cubic meters" : $"{rimTier.min:0} cubic meters");
			StringBuilder stringBuilder = new StringBuilder(RimTiers[0].name);
			for (int j = 1; j < RimTiers.Length; j++)
			{
				stringBuilder.Append(", ").Append(RimTiers[j].name.ToLowerInvariant());
			}
			return new string[29]
			{
				"Explosions remove terrain for real. Craters stay until the stage ends.",
				"Craters are synced in multiplayer. The hole you dig is the hole your friends fall into.",
				"The ground here is one byte per voxel. 0 is air, 255 is rock, your boots stand on 127.5.",
				"Terrain rebuilds in 16x16x16 chunks. An explosion only re-meshes the chunks it touched.",
				"Underground rock has no mesh until you expose it. Dig, and the new wall is built on the spot.",
				"Far terrain renders at lower detail. Craters and colliders never do — what you touch is exact.",
				"New crater walls borrow lighting from the nearest original wall. Re-baking would take minutes.",
				"The rocks flying out of craters are visual only. No collision — they fall through the floor on purpose.",
				"If a mesh looks wrong to convert, it stays vanilla. Guessing is how you get floating boxes.",
				"The teleporter never gets voxelized. We tried once. It became a cube.",
				"A stall near the end of the bar is normal. That's colliders baking — they take the longest.",
				"The host holds the stage until every player's terrain is ready. If nobody seems slow, it's you.",
				"Every cleared stage rolls a chance at a new title, and a separate chance at a card background pattern.",
				"Your first stage clear on a fresh profile always unlocks something.",
				"Country flags and pride flags are free for everyone from the start. Only patterns come from the lottery.",
				"Adjust your player card with Risk of Options: Settings > Mod Options, then Choose Title or Choose Card Background.",
				"Titles and card backgrounds only ever show on this loading screen. Nothing follows you into the run.",
				$"{num2} of the lottery patterns are animated. Two more wear a live shader borrowed from the game itself.",
				"Winning queues a prize. The reel under your card unlocks it: when the reel lands, it's yours.",
				"A reel cut off by the stage starting costs you nothing. The prize stays queued and spins again next screen.",
				"Carved m³ counts rock actually removed. Shooting air scores nothing.",
				"The rim around your portrait is lifetime rock removed. " + rimTier.name + " takes " + text + ".",
				$"{stringBuilder}. Every step is ten times the digging.",
				"Crowns go to the stage's top three players, ranked by kills, then damage, then rock carved.",
				"A reel spinning under a card means the lottery paid out. It always lands on the prize.",
				$"All {num} country flags in the card picker are painted pixel by pixel.",
				"Rock and Stone!",
				"Did I hear a Rock and Stone?",
				"For Karl!"
			};
		}

		public static void Show()
		{
			//IL_001a: 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_0022: Expected O, but got Unknown
			//IL_0027: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//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_00f2: 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_014d: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: 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_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Expected O, but got Unknown
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Expected O, but got Unknown
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			if (screen == null)
			{
				ScreenState screenState = (screen = new ScreenState());
				GameObject val = new GameObject("ScorchedVoxelsLoadingOverlay");
				GameObject val2 = val;
				screenState.go = val;
				GameObject val3 = val2;
				Canvas obj = val3.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 30000;
				CanvasScaler obj2 = val3.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1920f, 1080f);
				obj2.matchWidthOrHeight = 1f;
				UiKit.Stretch(((Graphic)UiKit.CreateImage("bg", val3.transform, ColBg)).rectTransform);
				UiMeter uiMeter = (screenState.bar = new UiMeter("barBg", val3.transform, new Vector2(728f, 24f), UiKit.PanelMid, ColOrange, 4f));
				uiMeter.Bg.sprite = UiKit.ChamferFill();
				uiMeter.Bg.type = (Type)1;
				uiMeter.Rect.anchoredPosition = new Vector2(0f, -462f);
				Image obj3 = UiKit.CreateOutline("barEdge", ((Component)uiMeter.Bg).transform, UiKit.Outline);
				UiKit.Stretch(((Graphic)obj3).rectTransform);
				((Component)obj3).transform.SetSiblingIndex(0);
				((Component)uiMeter.Bg).gameObject.AddComponent<Canvas>();
				UiKit.Label label = UiKit.CreateLabel("title", val3.transform, 36f, ColOrange, (TextAnchor)4);
				label.Rect.sizeDelta = new Vector2(1200f, 46f);
				label.Rect.anchoredPosition = new Vector2(0f, 512f);
				label.Bold();
				label.Text = "SCORCHED VOXELS";
				screenState.label = UiKit.CreateLabel("label", val3.transform, 22f, ColText, (TextAnchor)4);
				screenState.label.Rect.sizeDelta = new Vector2(1200f, 34f);
				screenState.label.Rect.anchoredPosition = new Vector2(0f, -430f);
				screenState.tipText = UiKit.CreateLabel("tip", val3.transform, 19f, ColDim, (TextAnchor)4);
				screenState.tipText.Rect.sizeDelta = new Vector2(1400f, 30f);
				screenState.tipText.Rect.anchoredPosition = new Vector2(0f, -385f);
				screenState.tipText.Italic();
				GameObject val4 = new GameObject("cards");
				val4.transform.SetParent(val3.transform, false);
				screenState.cardRow = val4.AddComponent<RectTransform>();
				screenState.cardRow.sizeDelta = new Vector2(1700f, 420f);
				screenState.cardRow.anchoredPosition = new Vector2(0f, 30f);
				Random random = new Random(Environment.TickCount);
				int[] array = (screenState.tipOrder = new int[Tips.Length]);
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = i;
				}
				for (int num = array.Length - 1; num > 0; num--)
				{
					int num2 = random.Next(num + 1);
					ref int reference = ref array[num];
					ref int reference2 = ref array[num2];
					int num3 = array[num2];
					int num4 = array[num];
					reference = num3;
					reference2 = num4;
				}
				screenState.shownAt = Time.unscaledTime;
				GameObject val5 = new GameObject("arcadeCanvas");
				val5.transform.SetParent(val3.transform, false);
				UiKit.Stretch(val5.AddComponent<RectTransform>());
				val5.AddComponent<Canvas>();
				val5.AddComponent<GraphicRaycaster>();
				UiKit.Stretch(((Graphic)UiKit.CreateImage("clickCatcher", val5.transform, Color.clear)).rectTransform);
				ArcadeHost.Attach(val5);
			}
		}

		public static void Tick()
		{
			ScreenState screenState = screen;
			if (screenState == null)
			{
				return;
			}
			long t = GoreProf.Begin();
			float num = ConvertProgress.Fraction();
			if (screenState.bar != null)
			{
				screenState.bar.SetFrac(num);
			}
			if (screenState.label != null)
			{
				string phase = ConvertProgress.Phase;
				if (ConvertProgress.IsPipeline(phase))
				{
					int num2 = (int)(num * 100f);
					if (phase != screenState.lastLabelPhase || num2 != screenState.lastLabelA || screenState.lastLabelB != -1)
					{
						screenState.lastLabelPhase = phase;
						screenState.lastLabelA = num2;
						screenState.lastLabelB = -1;
						screenState.label.Text = $"{phase} {num2}%";
					}
				}
				else if (ConvertProgress.Total > 1)
				{
					int done = ConvertProgress.Done;
					int total = ConvertProgress.Total;
					if (phase != screenState.lastLabelPhase || done != screenState.lastLabelA || total != screenState.lastLabelB)
					{
						screenState.lastLabelPhase = phase;
						screenState.lastLabelA = done;
						screenState.lastLabelB = total;
						screenState.label.Text = $"{phase} ({done}/{total})";
					}
				}
				else
				{
					screenState.lastLabelPhase = phase;
					screenState.lastLabelA = -1;
					screenState.lastLabelB = -1;
					screenState.label.Text = phase;
				}
			}
			if (screenState.tipText != null && screenState.tipOrder != null && screenState.tipOrder.Length != 0)
			{
				int num3 = (int)((Time.unscaledTime - screenState.shownAt) / 6f) % screenState.tipOrder.Length;
				if (num3 != screenState.lastTipIdx)
				{
					screenState.lastTipIdx = num3;
					screenState.tipText.Text = Tips[screenState.tipOrder[num3]];
				}
			}
			GoreProf.End(37, t);
			t = GoreProf.Begin();
			RefreshCards(screenState);
			GoreProf.End(38, t);
			t = GoreProf.Begin();
			UpdateReveal(screenState);
			GoreProf.End(39, t);
			t = GoreProf.Begin();
			BackgroundSystem.TickAnimated(Time.unscaledTime);
			GoreProf.End(40, t);
			ArcadeTheming.DestinationScene = NetworkManager.networkSceneName;
			t = GoreProf.Begin();
			ArcadeHost.Tick();
			GoreProf.End(41, t);
		}

		public static void Hide()
		{
			ArcadeHost.Detach();
			LootReveal.ReportShowActivity(active: false);
			NameFxSystem.Reset();
			ScreenState screenState = screen;
			screen = null;
			if (screenState != null && (Object)(object)screenState.go != (Object)null)
			{
				Object.Destroy((Object)(object)screenState.go);
			}
		}

		internal static bool TryGetLocalCardSlot(out float x, out float width, out float cardBottom)
		{
			//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)
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					return TryGetCardSlot(((NetworkInstanceId)(ref netId)).Value, out x, out width, out cardBottom);
				}
			}
			x = 0f;
			width = 0f;
			cardBottom = -180f;
			return false;
		}

		internal static bool TryGetCardTransform(uint userNetId, out Transform t, out float width)
		{
			t = null;
			width = 0f;
			ScreenState screenState = screen;
			if (screenState == null)
			{
				return false;
			}
			foreach (PlayerCard card in screenState.cards)
			{
				if (card.userNetId == userNetId && (Object)(object)card.go != (Object)null)
				{
					t = card.go.transform;
					width = card.width;
					return true;
				}
			}
			return false;
		}

		internal static bool TryGetCardSlot(uint userNetId, out float x, out float width, out float cardBottom)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0086: 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_00ba: 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)
			x = 0f;
			width = 0f;
			cardBottom = -180f;
			ScreenState screenState = screen;
			if (screenState == null || (Object)(object)screenState.cardRow == (Object)null || screenState.cards.Count == 0)
			{
				return false;
			}
			foreach (PlayerCard card in screenState.cards)
			{
				if (card.userNetId == userNetId && !((Object)(object)card.go == (Object)null))
				{
					RectTransform val = (RectTransform)card.go.transform;
					x = screenState.cardRow.anchoredPosition.x + val.anchoredPosition.x * screenState.wallScale;
					width = card.width * screenState.wallScale;
					cardBottom = screenState.cardRow.anchoredPosition.y + (val.anchoredPosition.y - 210f) * screenState.wallScale;
					return true;
				}
			}
			return false;
		}

		internal static void InvalidateCards()
		{
			if (screen != null)
			{
				screen.needCardRebuild = true;
			}
		}

		private static void UpdateReveal(ScreenState state)
		{
			//IL_010a: 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_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_073a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0872: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0911: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bf: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<(uint, byte), ReelView> reelViews = state.reelViews;
			float unscaledTime = Time.unscaledTime;
			if (reelViews.Count > 0)
			{
				reelPruneScratch.Clear();
				foreach (KeyValuePair<(uint, byte), ReelView> item in reelViews)
				{
					if ((Object)(object)item.Value.root == (Object)null)
					{
						reelPruneScratch.Add(item.Key);
					}
				}
				foreach (var item2 in reelPruneScratch)
				{
					reelViews.Remove(item2);
				}
			}
			if (!ArcadeHost.CeremonyClosed)
			{
				foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
				{
					if ((Object)(object)readOnlyInstances == (Object)null || !((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
					{
						continue;
					}
					string text = UserLifetimeStats.ProfileKey(readOnlyInstances);
					if (text == null || !UserLifetimeStats.TryPeekPending(text, out var kind, out var idx))
					{
						continue;
					}
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					uint value = ((NetworkInstanceId)(ref netId)).Value;
					bool flag = false;
					foreach (LootReel reel in LootReveal.Reels)
					{
						if (reel.userNetId == value && !state.reelsSettled.Contains((value, reel.seq)) && !state.reelsSkipped.Contains((value, reel.seq)))
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						(uint, byte, int) key = (value, kind, idx);
						if (!state.reelReportedAt.ContainsKey(key))
						{
							state.reelReportedAt[key] = unscaledTime;
							LootReveal.ReportLocalWin(readOnlyInstances, (PrizeKind)kind, idx);
						}
					}
				}
			}
			foreach (LootReel reel2 in LootReveal.Reels)
			{
				(uint, byte) tuple = (reel2.userNetId, reel2.seq);
				if (reelViews.ContainsKey(tuple) || state.reelsSkipped.Contains(tuple) || state.reelsSettled.Contains(tuple))
				{
					continue;
				}
				bool flag2 = false;
				foreach (LootReel reel3 in LootReveal.Reels)
				{
					if (reel3.userNetId == reel2.userNetId && reel3.seq < reel2.seq && !state.reelsSettled.Contains((reel3.userNetId, reel3.seq)) && !state.reelsSkipped.Contains((reel3.userNetId, reel3.seq)))
					{
						flag2 = true;
						break;
					}
				}
				if (flag2)
				{
					continue;
				}
				PlayerCard playerCard = null;
				foreach (PlayerCard card in state.cards)
				{
					if (card.userNetId == reel2.userNetId)
					{
						playerCard = card;
						break;
					}
				}
				if (playerCard == null || (Object)(object)playerCard.go == (Object)null)
				{
					if (!state.reelsAwaitingCard.TryGetValue(tuple, out var value2))
					{
						state.reelsAwaitingCard[tuple] = unscaledTime;
					}
					else if (unscaledTime - value2 > 3f)
					{
						state.reelsAwaitingCard.Remove(tuple);
						state.reelsSkipped.Add(tuple);
						ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] " + reel2.userName + "'s reveal has no card to spin under — prize stays queued, reel skipped"));
					}
					continue;
				}
				state.reelsAwaitingCard.Remove(tuple);
				if (ArcadeHost.CeremonyClosed)
				{
					state.reelsSkipped.Add(tuple);
					ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] " + reel2.userName + "'s reveal arrived after the ceremony window — prize stays queued for the next screen"));
					continue;
				}
				ReelView reelView = BuildReelStrip(reel2, playerCard);
				if (!state.reelShowT0.TryGetValue(tuple, out var value3))
				{
					value3 = unscaledTime + 1.1f;
					state.reelShowT0[tuple] = value3;
				}
				reelView.showT0 = value3;
				reelViews[tuple] = reelView;
			}
			LootReveal.ReportShowActivity(reelViews.Count > 0 || AnyReelAwaitingShow);
			if (reelViews.Count == 0)
			{
				return;
			}
			reelPruneScratch.Clear();
			foreach (KeyValuePair<(uint, byte), ReelView> item3 in reelViews)
			{
				ReelView value4 = item3.Value;
				if ((Object)(object)value4.root == (Object)null)
				{
					continue;
				}
				float num = (unscaledTime - value4.showT0) / 4.6f;
				float num2 = Mathf.Clamp01(num);
				float num3 = 1f - Mathf.Pow(1f - num2, 3f);
				if (ModOptions.RevealSounds.Value)
				{
					if (num >= 0f && !value4.startSoundPlayed)
					{
						value4.startSoundPlayed = true;
						if (unscaledTime - state.lastReelStartSoundAt >= 0.5f)
						{
							state.lastReelStartSoundAt = unscaledTime;
							PlayUiSound("Play_UI_tripleChestShutter");
						}
					}
					int num4 = 21;
					int num5 = Mathf.Min(Mathf.FloorToInt((float)num4 * num3), num4);
					if (num5 > value4.ticksPlayed)
					{
						value4.ticksPlayed = num5;
						if (num2 < 1f && unscaledTime - state.reelLastTickAt >= 0.045f)
						{
							state.reelLastTickAt = unscaledTime;
							PlayUiSound("Play_UI_menuHover");
						}
					}
				}
				if ((Object)(object)value4.group != (Object)null)
				{
					value4.group.alpha = Mathf.Clamp01((unscaledTime - value4.spawnedAt) / 0.35f);
				}
				if ((Object)(object)value4.content != (Object)null)
				{
					value4.content.anchoredPosition = new Vector2(Mathf.Lerp(value4.pStart, value4.pEnd, num3), 0f);
				}
				if (value4.fxTiles != null && value4.root.activeSelf)
				{
					foreach (var (label, fx) in value4.fxTiles)
					{
						NameFxSystem.Animate(label, fx, value4.reel.userNetId * 2654435761u, unscaledTime);
					}
				}
				if (value4.reel.kind == PrizeKind.Background && value4.root.activeSelf)
				{
					int[] entries = value4.reel.entries;
					for (int i = 0; i < entries.Length; i++)
					{
						BackgroundSystem.MarkAnimatedVisible(entries[i]);
					}
				}
				if ((Object)(object)value4.marker != (Object)null && !value4.landed)
				{
					Color colGold = ColGold;
					colGold.a = 0.65f + 0.35f * Mathf.Sin(unscaledTime * 9f);
					((Graphic)value4.marker).color = colGold;
				}
				if (num2 >= 1f && !value4.landed)
				{
					value4.landed = true;
					value4.landedAt = unscaledTime;
					if ((Object)(object)value4.marker != (Object)null)
					{
						((Graphic)value4.marker).color = ColGold;
					}
					if ((Object)(object)value4.landFrame != (Object)null)
					{
						((Behaviour)value4.landFrame).enabled = true;
					}
					if ((Object)(object)value4.flash != (Object)null)
					{
						((Behaviour)value4.flash).enabled = true;
					}
					if ((Object)(object)value4.wonTile != (Object)null)
					{
						((Transform)value4.wonTile).SetAsLastSibling();
					}
					if (value4.caption != null)
					{
						value4.caption.Text = value4.reel.WonName;
						value4.caption.Color = ColGold;
					}
					LootReveal.ApplyLanded(value4.reel);
					if (ModOptions.RevealSounds.Value && unscaledTime - state.lastReelLandSoundAt >= 0.3f)
					{
						state.lastReelLandSoundAt = unscaledTime;
						PlayUiSound("Play_UI_achievementUnlock");
					}
				}
				if (!value4.landed)
				{
					continue;
				}
				float num6 = unscaledTime - value4.landedAt;
				if ((Object)(object)value4.flash != (Object)null)
				{
					float num7 = 0.5f * (1f - Mathf.Clamp01(num6 / 0.4f));
					if (num7 <= 0f)
					{
						((Behaviour)value4.flash).enabled = false;
					}
					else
					{
						((Graphic)value4.flash).color = new Color(1f, 0.95f, 0.75f, num7);
					}
				}
				if ((Object)(object)value4.wonTile != (Object)null && num6 <= 0.5f)
				{
					float num8 = 1f + 0.13f * Mathf.Sin(MathF.PI * Mathf.Clamp01(num6 / 0.45f));
					((Transform)value4.wonTile).localScale = new Vector3(num8, num8, 1f);
				}
				if ((Object)(object)value4.landFrame != (Object)null)
				{
					Color colGold2 = ColGold;
					colGold2.a = 0.72f + 0.28f * Mathf.Sin(num6 * 5f);
					((Graphic)value4.landFrame).color = colGold2;
				}
				if (num6 > 3f && (Object)(object)value4.group != (Object)null)
				{
					value4.group.alpha = Mathf.Clamp01(1f - (num6 - 3f) / 0.5f);
					if (value4.group.alpha <= 0f && value4.root.activeSelf)
					{
						value4.root.SetActive(false);
					}
				}
				if (num6 >= 3.5f)
				{
					if (value4.root.activeSelf)
					{
						value4.root.SetActive(false);
					}
					reelPruneScratch.Add(item3.Key);
				}
			}
			foreach (var item4 in reelPruneScratch)
			{
				state.reelsSettled.Add(item4);
				reelViews.Remove(item4);
			}
		}

		private static ReelView BuildReelStrip(LootReel reel, PlayerCard card)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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_0116: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: 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_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0623: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_0671: Unknown result type (might be due to invalid IL or missing references)
			//IL_068f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_0737: Unknown result type (might be due to invalid IL or missing references)
			//IL_0779: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			ReelView reelView = new ReelView
			{
				reel = reel,
				spawnedAt = Time.unscaledTime
			};
			float width = card.width;
			reelView.root = new GameObject("lootReel");
			reelView.root.transform.SetParent(card.go.transform, false);
			RectTransform obj = reelView.root.AddComponent<RectTransform>();
			obj.sizeDelta = new Vector2(width, 90f);
			obj.anchoredPosition = new Vector2(0f, -260f);
			reelView.root.AddComponent<Canvas>();
			reelView.group = reelView.root.AddComponent<CanvasGroup>();
			reelView.group.alpha = 0f;
			reelView.group.blocksRaycasts = false;
			reelView.group.interactable = false;
			reelView.caption = UiKit.CreateLabel("caption", reelView.root.transform, 13f, ColTitle, (TextAnchor)4);
			reelView.caption.Rect.sizeDelta = new Vector2(width, 18f);
			reelView.caption.Rect.anchoredPosition = new Vector2(0f, 34f);
			reelView.caption.ClipSingleLine();
			reelView.caption.Text = ((reel.kind == PrizeKind.Title) ? "WON A TITLE!" : ((reel.kind == PrizeKind.NameFx) ? "THE PET DUG UP A NAME EFFECT!" : "WON A CARD BACKGROUND!"));
			Image val = UiKit.CreatePanel("strip", reelView.root.transform, new Color(0.045f, 0.05f, 0.07f, 1f));
			((Graphic)val).rectTransform.sizeDelta = new Vector2(width, 54f);
			((Graphic)val).rectTransform.anchoredPosition = new Vector2(0f, -4f);
			GameObject val2 = new GameObject("mask");
			val2.transform.SetParent(((Component)val).transform, false);
			RectTransform obj2 = val2.AddComponent<RectTransform>();
			UiKit.Stretch(obj2);
			obj2.offsetMin = new Vector2(3f, 3f);
			obj2.offsetMax = new Vector2(-3f, -3f);
			val2.AddComponent<RectMask2D>();
			GameObject val3 = new GameObject("reel");
			val3.transform.SetParent(val2.transform, false);
			reelView.content = val3.AddComponent<RectTransform>();
			reelView.content.anchorMin = new Vector2(0.5f, 0.5f);
			reelView.content.anchorMax = new Vector2(0.5f, 0.5f);
			reelView.content.pivot = new Vector2(0f, 0.5f);
			reelView.content.sizeDelta = new Vector2(10f, 54f);
			float num = 44f;
			float num2 = ((reel.kind == PrizeKind.Background) ? Mathf.Round(num * 2f / 3f) : 84f);
			reelView.stride = num2 + 6f;
			for (int i = 0; i < reel.entries.Length; i++)
			{
				int num3 = reel.entries[i];
				Image val4 = UiKit.CreatePanel($"item_{i}", (Transform)(object)reelView.content, UiKit.PanelMid);
				((Graphic)val4).raycastTarget = false;
				((Graphic)val4).rectTransform.anchorMin = new Vector2(0f, 0.5f);
				((Graphic)val4).rectTransform.anchorMax = new Vector2(0f, 0.5f);
				((Graphic)val4).rectTransform.sizeDelta = new Vector2(num2, num);
				((Graphic)val4).rectTransform.anchoredPosition = new Vector2((float)i * reelView.stride, 0f);
				if (i == reel.landSlot)
				{
					reelView.wonTile = ((Graphic)val4).rectTransform;
				}
				if (reel.kind == PrizeKind.Background)
				{
					UiKit.CreateMaskedCard("pv", val4, (Texture)(object)BackgroundSystem.GetTexture(num3));
				}
				else if (reel.kind == PrizeKind.NameFx)
				{
					UiKit.Label label = UiKit.CreateLabel("t", ((Component)val4).transform, 10f, ColText, (TextAnchor)4);
					UiKit.Stretch(label.Rect);
					label.Rect.offsetMin = new Vector2(4f, 1f);
					label.Rect.offsetMax = new Vector2(-4f, -1f);
					label.WrapClipped();
					label.Text = ((num3 >= 0 && num3 < NameFxSystem.Table.Length) ? NameFxSystem.Table[num3].name : "?");
					ReelView reelView2 = reelView;
					if (reelView2.fxTiles == null)
					{
						reelView2.fxTiles = new List<(UiKit.Label, int)>();
					}
					reelView.fxTiles.Add((label, num3));
				}
				else
				{
					UiKit.Label label2 = UiKit.CreateLabel("t", ((Component)val4).transform, 10f, ColText, (TextAnchor)4);
					UiKit.Stretch(label2.Rect);
					label2.Rect.offsetMin = new Vector2(4f, 1f);
					label2.Rect.offsetMax = new Vector2(-4f, -1f);
					label2.WrapClipped();
					label2.Text = ((num3 >= 0 && num3 < TitleSystem.Table.Length) ? TitleSystem.Table[num3] : "?");
				}
			}
			Color color = default(Color);
			((Color)(ref color))..ctor(0.045f, 0.05f, 0.07f, 0.95f);
			Image obj3 = UiKit.CreateImage("shadeL", ((Component)val).transform, color);
			obj3.sprite = EdgeFadeSprite();
			((Graphic)obj3).raycastTarget = false;
			((Graphic)obj3).rectTransform.anchorMin = new Vector2(0f, 0f);
			((Graphic)obj3).rectTransform.anchorMax = new Vector2(0f, 1f);
			((Graphic)obj3).rectTransform.pivot = new Vector2(0f, 0.5f);
			((Graphic)obj3).rectTransform.offsetMin = new Vector2(3f, 3f);
			((Graphic)obj3).rectTransform.offsetMax = new Vector2(25f, -3f);
			Image obj4 = UiKit.CreateImage("shadeR", ((Component)val).transform, color);
			obj4.sprite = EdgeFadeSprite();
			((Graphic)obj4).raycastTarget = false;
			((Graphic)obj4).rectTransform.anchorMin = new Vector2(1f, 0f);
			((Graphic)obj4).rectTransform.anchorMax = new Vector2(1f, 1f);
			((Graphic)obj4).rectTransform.offsetMin = new Vector2(-25f, 3f);
			((Graphic)obj4).rectTransform.offsetMax = new Vector2(-3f, -3f);
			((Transform)((Graphic)obj4).rectTransform).localScale = new Vector3(-1f, 1f, 1f);
			reelView.marker = UiKit.CreateImage("marker", ((Component)val).transform, ColGold);
			((Graphic)reelView.marker).rectTransform.sizeDelta = new Vector2(2f, 60f);
			((Graphic)reelView.marker).raycastTarget = false;
			reelView.landFrame = UiKit.CreateOutline("landFrame", ((Component)val).transform, ColGold);
			((Graphic)reelView.landFrame).rectTransform.sizeDelta = new Vector2(num2 + 8f, num + 8f);
			((Behaviour)reelView.landFrame).enabled = false;
			reelView.flash = UiKit.CreateImage("flash", ((Component)val).transform, Color.clear);
			UiKit.Stretch(((Graphic)reelView.flash).rectTransform);
			((Graphic)reelView.flash).raycastTarget = false;
			((Behaviour)reelView.flash).enabled = false;
			UiKit.Stretch(((Graphic)UiKit.CreateOutline("stripEdge", ((Component)val).transform, UiKit.Outline)).rectTransform);
			reelView.pEnd = (float)(-reel.landSlot) * reelView.stride;
			reelView.pStart = -2f * reelView.stride;
			reelView.content.anchoredPosition = new Vector2(reelView.pStart, 0f);
			return reelView;
		}

		private static Sprite EdgeFadeSprite()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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)
			if ((Object)(object)edgeFadeSprite != (Object)null)
			{
				return edgeFadeSprite;
			}
			Texture2D val = new Texture2D(32, 1, (TextureFormat)5, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[32];
			for (int i = 0; i < 32; i++)
			{
				float num = (float)i / 31f;
				array[i] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)((1f - num) * (1f - num) * 255f));
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			edgeFadeSprite = Sprite.Create(val, new Rect(0f, 0f, 32f, 1f), new Vector2(0.5f, 0.5f), 100f);
			return edgeFadeSprite;
		}

		private static void PlayUiSound(string eventName)
		{
			try
			{
				RoR2Application instance = RoR2Application.instance;
				if ((Object)(object)instance != (Object)null)
				{
					Util.PlaySound(eventName, ((Component)instance).gameObject);
				}
			}
			catch
			{
			}
		}

		private static string Compact(ulong v)
		{
			if (v < 10000)
			{
				return v.ToString();
			}
			if (v < 1000000)
			{
				return $"{(float)v / 1000f:F1}k";
			}
			return $"{(float)v / 1000000f:F2}M";
		}

		private static string Cubic(double m3)
		{
			string cubicSuffix = UiKit.CubicSuffix;
			if (m3 < 10.0)
			{
				return $"{m3:F1} {cubicSuffix}";
			}
			if (m3 < 10000.0)
			{
				return $"{Math.Round(m3)} {cubicSuffix}";
			}
			if (m3 < 1000000.0)
			{
				return $"{m3 / 1000.0:F1}k {cubicSuffix}";
			}
			if (m3 < 1000000000.0)
			{
				return $"{m3 / 1000000.0:F2}M {cubicSuffix}";
			}
			return $"{m3 / 1000000000.0:F2}B {cubicSuffix}";
		}

		private static Sprite BuildCrownSprite()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_00ec: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(96, 88, (TextureFormat)5, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[8448];
			for (int i = 0; i < 88; i++)
			{
				for (int j = 0; j < 96; j++)
				{
					int num = 0;
					for (int k = 0; k < 3; k++)
					{
						for (int l = 0; l < 3; l++)
						{
							if (Inside((float)j + ((float)l + 0.5f) / 3f, (float)i + ((float)k + 0.5f) / 3f))
							{
								num++;
							}
						}
					}
					byte b = (byte)(num * 255 / 9);
					array[i * 96 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			return Sprite.Create(val, new Rect(0f, 0f, 96f, 88f), new Vector2(0.5f, 0.5f), 100f);
			static bool Inside(float x, float y)
			{
				if (y >= 6f && y <= 20f && x >= 4f && x <= 92f)
				{
					return true;
				}
				if (Spike(16f, 14f, 60f) || Spike(48f, 16f, 72f) || Spike(80f, 14f, 60f))
				{
					return true;
				}
				if (!Ball(16f, 62f) && !Ball(48f, 74f))
				{
					return Ball(80f, 62f);
				}
				return true;
				bool Ball(float bx, float by)
				{
					float num2 = x - bx;
					float num3 = y - by;
					return num2 * num2 + num3 * num3 <= 36f;
				}
				bool Spike(float cx, float hw, float ytip)
				{
					if (y > 20f && y <= ytip)
					{
						return Mathf.Abs(x - cx) <= hw * (1f - (y - 20f) / (ytip - 20f));
					}
					return false;
				}
			}
		}
	}
	internal static class ConvertProgress
	{
		public static volatile string Phase = "";

		public static int Done;

		public static int Total;

		private static readonly (string phase, float start, float end)[] Slices = new(string, float, float)[4]
		{
			("preparing", 0f, 0.03f),
			("voxelizing terrain", 0.03f, 0.45f),
			("building meshes", 0.45f, 0.9f),
			("baking colliders", 0.9f, 1f)
		};

		public static bool IsPipeline(string phase)
		{
			(string, float, float)[] slices = Slices;
			for (int i = 0; i < slices.Length; i++)
			{
				if (slices[i].Item1 == phase)
				{
					return true;
				}
			}
			return false;
		}

		public static void Set(string phase, int total)
		{
			Phase = phase;
			Done = 0;
			Total = total;
		}

		public static float Fraction()
		{
			string phase = Phase;
			int total = Total;
			float num = ((total > 0) ? Mathf.Clamp01((float)Done / (float)total) : 0f);
			(string, float, float)[] slices = Slices;
			for (int i = 0; i < slices.Length; i++)
			{
				(string, float, float) tuple = slices[i];
				if (tuple.Item1 == phase)
				{
					return tuple.Item2 + (tuple.Item3 - tuple.Item2) * num;
				}
			}
			return num;
		}
	}
	internal enum PrizeKind : byte
	{
		Title,
		Background,
		NameFx
	}
	internal class LootReel
	{
		public uint userNetId;

		public string userName;

		public PrizeKind kind;

		public byte seq;

		public int stageKey;

		public int landSlot;

		public int[] entries;

		public int WonIndex => entries[landSlot];

		public string WonName
		{
			get
			{
				if (kind != PrizeKind.Title)
				{
					if (kind != PrizeKind.NameFx)
					{
						return BackgroundSystem.Table[Mathf.Clamp(WonIndex, 0, BackgroundSystem.Table.Length - 1)].name;
					}
					return NameFxSystem.Table[Mathf.Clamp(WonIndex, 0, NameFxSystem.Table.Length - 1)].name;
				}
				return TitleSystem.Table[Mathf.Clamp(WonIndex, 0, TitleSystem.Table.Length - 1)];
			}
		}
	}
	internal static class LootReveal
	{
		public const float StartDelay = 1.1f;

		public const float SpinSeconds = 4.6f;

		public const float LingerSeconds = 1.4f;

		public const float MaxHoldSeconds = 30f;

		private const int ReelLength = 28;

		public const int LandSlot = 23;

		public const int StartSlot = 2;

		public static readonly List<LootReel> Reels = new List<LootReel>();

		private static readonly Random rng = new Random();

		private static float showActiveSince = -1f;

		private static readonly Dictionary<uint, byte> seqCounters = new Dictionary<uint, byte>();

		private static int seqStage = int.MinValue;

		public static bool RevealRunning { get; private set; }

		public static bool HoldingRelease { get; private set; }

		public static int StageKey { get; private set; } = int.MinValue;

		public static void ReportShowActivity(bool active)
		{
			if (!active)
			{
				showActiveSince = -1f;
				HoldingRelease = false;
				return;
			}
			if (showActiveSince < 0f)
			{
				showActiveSince = Time.unscaledTime;
			}
			HoldingRelease = Time.unscaledTime - showActiveSince < 30f;
		}

		public static int CurrentStageKey()
		{
			if (!((Object)(object)Run.instance != (Object)null))
			{
				return -1;
			}
			return Run.instance.stageClearCount;
		}

		public static void ResetForStage(int stageKey)
		{
			StageKey = stageKey;
			Reels.RemoveAll((LootReel r) => r.stageKey != stageKey);
			RevealRunning = false;
			HoldingRelease = false;
			showActiveSince = -1f;
		}

		public static void Reset()
		{
			StageKey = int.MinValue;
			Reels.Clear();
			RevealRunning = false;
			HoldingRelease = false;
			showActiveSince = -1f;
		}

		public static void ReportLocalWin(NetworkUser nu, PrizeKind kind, int wonIdx)
		{
			//IL_0036: 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_0019: 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 (!((Object)(object)nu == (Object)null))
			{
				int stageKey = CurrentStageKey();
				NetworkInstanceId netId;
				if (NetworkServer.active)
				{
					netId = ((NetworkBehaviour)nu).netId;
					ServerQueueReveal(stageKey, ((NetworkInstanceId)(ref netId)).Value, nu.userName, kind, wonIdx);
				}
				else
				{
					netId = ((NetworkBehaviour)nu).netId;
					NetMessageExtensions.Send((INetMessage)(object)new UnlockRevealMessage(stageKey, ((NetworkInstanceId)(ref netId)).Value, kind, wonIdx), (NetworkDestination)2);
				}
			}
		}

		private static byte NextSeq(int stageKey, uint netId)
		{
			if (stageKey != seqStage)
			{
				seqStage = stageKey;
				seqCounters.Clear();
			}
			seqCounters.TryGetValue(netId, out var value);
			seqCounters[netId] = (byte)(value + 1);
			return value;
		}

		public static void ServerQueueReveal(int stageKey, uint userNetId, string userName, PrizeKind kind, int wonIdx)
		{
			if (!NetworkServer.active)
			{
				return;
			}
			if (stageKey < 0 || stageKey != CurrentStageKey())
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"[ScorchedVoxels] loot reveal for netId {userNetId} carries stage key {stageKey} (current {CurrentStageKey()}) — prize stays queued, reveal dropped");
				return;
			}
			foreach (LootReel reel in Reels)
			{
				if (reel.stageKey == stageKey && reel.userNetId == userNetId && reel.kind == kind && reel.WonIndex == wonIdx)
				{
					return;
				}
			}
			if (string.IsNullOrEmpty(userName))
			{
				userName = ResolveName(userNetId);
			}
			LootReel lootReel = BuildReel(userNetId, userName, kind, wonIdx);
			lootReel.stageKey = stageKey;
			lootReel.seq = NextSeq(stageKey, userNetId);
			Reels.Add(lootReel);
			NetMessageExtensions.Send((INetMessage)(object)new LootReelMessage(lootReel), (NetworkDestination)1);
		}

		private static string ResolveName(uint id)
		{
			//IL_001e: 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)
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					if (((NetworkInstanceId)(ref netId)).Value == id)
					{
						return readOnlyInstances.userName;
					}
				}
			}
			return "Someone";
		}

		private static LootReel BuildReel(uint userNetId, string userName, PrizeKind kind, int wonIdx)
		{
			List<int> list = new List<int>();
			switch (kind)
			{
			case PrizeKind.Title:
			{
				for (int j = 0; j < TitleSystem.Table.Length; j++)
				{
					if (j != wonIdx)
					{
						list.Add(j);
					}
				}
				break;
			}
			case PrizeKind.NameFx:
			{
				for (int k = 0; k < NameFxSystem.Table.Length; k++)
				{
					if (k != wonIdx)
					{
						list.Add(k);
					}
				}
				break;
			}
			default:
			{
				for (int i = 0; i < BackgroundSystem.Table.Length; i++)
				{
					if (i != wonIdx && BackgroundSystem.Table[i].cat == BgCat.Pattern)
					{
						list.Add(i);
					}
				}
				break;
			}
			}
			if (list.Count == 0)
			{
				list.Add(wonIdx);
			}
			int[] array = new int[28];
			for (int l = 0; l < 28; l++)
			{
				array[l] = list[rng.Next(list.Count)];
			}
			array[23] = wonIdx;
			return new LootReel
			{
				userNetId = userNetId,
				userName = userName,
				kind = kind,
				landSlot = 23,
				entries = array
			};
		}

		public static bool TryDeferRelease()
		{
			if (!HoldingRelease)
			{
				return false;
			}
			RevealRunning = true;
			return true;
		}

		public static void FinishReveal()
		{
			RevealRunning = false;
		}

		public static void ClientStoreReel(LootReel reel)
		{
			foreach (LootReel reel2 in Reels)
			{
				if (reel2.userNetId == reel.userNetId && reel2.seq == reel.seq && reel2.stageKey == reel.stageKey)
				{
					return;
				}
			}
			Reels.Add(reel);
		}

		public static void ApplyLanded(LootReel reel)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			NetworkUser val = null;
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					if (((NetworkInstanceId)(ref netId)).Value == reel.userNetId)
					{
						val = readOnlyInstances;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			string text = UserLifetimeStats.ProfileKey(val);
			if (text == null)
			{
				return;
			}
			int wonIndex = reel.WonIndex;
			if (UserLifetimeStats.DequeuePending(text, (byte)reel.kind, wonIndex))
			{
				switch (reel.kind)
				{
				case PrizeKind.Title:
					UserLifetimeStats.AddTitle(text, wonIndex);
					TitleSystem.MarkFresh(reel.userNetId);
					break;
				case PrizeKind.Background:
					UserLifetimeStats.AddBackground(text, wonIndex);
					break;
				default:
					UserLifetimeStats.UnlockNameFx(text, wonIndex);
					break;
				}
				ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] " + val.userName + "'s reel landed: '" + reel.WonName + "' is now unlocked"));
				StageSyncCoordinator.OnLocalCardMetaChanged();
			}
		}

		public static void ServerResendReels()
		{
			if (!NetworkServer.active)
			{
				return;
			}
			int num = CurrentStageKey();
			foreach (LootReel reel in Reels)
			{
				if (reel.stageKey == num)
				{
					NetMessageExtensions.Send((INetMessage)(object)new LootReelMessage(reel), (NetworkDestination)1);
				}
			}
		}
	}
	internal class UnlockRevealMessage : INetMessage, ISerializableObject
	{
		private int stageKey;

		private uint userNetId;

		private byte kind;

		private int wonIdx;

		public UnlockRevealMessage()
		{
		}

		public UnlockRevealMessage(int stageKey, uint userNetId, PrizeKind kind, int wonIdx)
		{
			this.stageKey = stageKey;
			this.userNetId = userNetId;
			this.kind = (byte)kind;
			this.wonIdx = wonIdx;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32((uint)(stageKey + 1));
			writer.WritePackedUInt32(userNetId);
			writer.Write(kind);
			writer.WritePackedUInt32((uint)wonIdx);
		}

		public void Deserialize(NetworkReader reader)
		{
			stageKey = (int)(reader.ReadPackedUInt32() - 1);
			userNetId = reader.ReadPackedUInt32();
			kind = reader.ReadByte();
			wonIdx = (int)reader.ReadPackedUInt32();
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				LootReveal.ServerQueueReveal(stageKey, userNetId, null, (PrizeKind)kind, wonIdx);
			}
		}
	}
	internal class LootReelMessage : INetMessage, ISerializableObject
	{
		private LootReel reel = new LootReel();

		public LootReelMessage()
		{
		}

		public LootReelMessage(LootReel reel)
		{
			this.reel = reel;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32((uint)(reel.stageKey + 1));
			writer.WritePackedUInt32(reel.userNetId);
			writer.Write(reel.userName ?? "Someone");
			writer.Write((byte)reel.kind);
			writer.Write(reel.seq);
			writer.Write((byte)reel.landSlot);
			writer.Write((byte)reel.entries.Length);
			int[] entries = reel.entries;
			foreach (int num in entries)
			{
				writer.WritePackedUInt32((uint)num);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			reel = new LootReel
			{
				stageKey = (int)(reader.ReadPackedUInt32() - 1),
				userNetId = reader.ReadPackedUInt32(),
				userName = reader.ReadString(),
				kind = (PrizeKind)reader.ReadByte(),
				seq = reader.ReadByte(),
				landSlot = reader.ReadByte()
			};
			reel.entries = new int[reader.ReadByte()];
			for (int i = 0; i < reel.entries.Length; i++)
			{
				reel.entries[i] = (int)reader.ReadPackedUInt32();
			}
		}

		public void OnReceived()
		{
			if (!NetworkServer.active && reel.entries.Length != 0 && reel.landSlot < reel.entries.Length && reel.stageKey >= 0 && reel.stageKey == LootReveal.CurrentStageKey())
			{
				LootReveal.ClientStoreReel(reel);
			}
		}
	}
	internal static class NameFxSystem
	{
		public enum Tier : byte
		{
			White,
			Green,
			Red,
			Lunar
		}

		public struct Def
		{
			public readonly string name;

			public readonly Tier tier;

			public Def(string name, Tier tier)
			{
				this.name = name;
				this.tier = tier;
			}
		}

		private class MoteState
		{
			public readonly List<Mote> live = new List<Mote>(8);

			public readonly Stack<Image> pool = new Stack<Image>(8);

			public float nextSpawnAt;
		}

		private class Mote
		{
			public Image img;

			public Vector2 pos;

			public Vector2 vel;

			public Vector2 attract;

			public float life;

			public float maxLife;

			public Color col;
		}

		private class FractalState
		{
			public RawImage img;

			public Texture2D tex;

			public byte[] rgba;

			public NamePlates.Plate plate;

			public string srcText;

			public float nextAt;
		}

		public static readonly Def[] Table = new Def[37]
		{
			new Def("Wormfood", Tier.White),
			new Def("Celestine", Tier.White),
			new Def("Frosted", Tier.White),
			new Def("Burnished", Tier.White),
			new Def("Oiled", Tier.White),
			new Def("Hymn", Tier.White),
			new Def("Bleeding", Tier.Green),
			new Def("Acidic", Tier.Green),
			new Def("Ember", Tier.Green),
			new Def("Cracked", Tier.Green),
			new Def("Echo", Tier.Green),
			new Def("Overloading", Tier.Red),
			new Def("Gilded", Tier.Red),
			new Def("Magmatic", Tier.Lunar),
			new Def("Voidtouched", Tier.Lunar),
			new Def("Seismic", Tier.Green),
			new Def("Prismatic", Tier.Red),
			new Def("Chiseled", Tier.Red),
			new Def("Fractal", Tier.Lunar),
			new Def("Constellation", Tier.Green),
			new Def("Verdant", Tier.White),
			new Def("Abyssal", Tier.White),
			new Def("Rusted", Tier.White),
			new Def("Twilight", Tier.White),
			new Def("Stormcloud", Tier.Green),
			new Def("Glitched", Tier.Green),
			new Def("Swarm", Tier.Green),
			new Def("Tidal", Tier.Green),
			new Def("Neon", Tier.Green),
			new Def("Solar", Tier.Red),
			new Def("Spectral", Tier.Red),
			new Def("Bloodmoon", Tier.Red),
			new Def("Razor", Tier.Red),
			new Def("Aurora", Tier.Lunar),
			new Def("Reactor", Tier.Lunar),
			new Def("Hivemind", Tier.Lunar),
			new Def("Phoenix", Tier.Lunar)
		};

		public const int Magmatic = 13;

		public const int Voidtouched = 14;

		private static readonly Color32 EmberGlow = new Color32(byte.MaxValue, (byte)97, (byte)18, byte.MaxValue);

		private static readonly Color32 AcidPulse = new Color32((byte)76, byte.MaxValue, (byte)25, byte.MaxValue);

		private static readonly Color32 FrostSkin = new Color32((byte)158, (byte)204, byte.MaxValue, byte.MaxValue);

		private static readonly Color32 ArcGlow = new Color32((byte)204, byte.MaxValue, byte.MaxValue, byte.MaxValue);

		private static readonly Color32 VoidGlow = new Color32((byte)140, (byte)38, (byte)242, byte.MaxValue);

		private static readonly Color32 LunarGlow = new Color32((byte)140, (byte)173, byte.MaxValue, byte.MaxValue);

		private static readonly Color32 Gold = new Color32((byte)217, (byte)158, (byte)36, byte.MaxValue);

		private static readonly Color32 Oil = new Color32((byte)120, (byte)124, (byte)136, byte.MaxValue);

		private static readonly Color32 Umber = new Color32((byte)150, (byte)112, (byte)74, byte.MaxValue);

		private static readonly Color32 Blood = new Color32((byte)140, (byte)22, (byte)22, byte.MaxValue);

		private static readonly HashSet<TMP_Text> canvased = new HashSet<TMP_Text>();

		private static readonly Dictionary<TMP_Text, float> lastTick = new Dictionary<TMP_Text, float>();

		private static readonly Dictionary<TMP_Text, MoteState> motes = new Dictionary<TMP_Text, MoteState>();

		private static readonly Dictionary<TMP_Text, Material> glowMats = new Dictionary<TMP_Text, Material>();

		private static readonly Dictionary<TMP_Text, Material> chiselMat = new Dictionary<TMP_Text, Material>();

		private static readonly Dictionary<TMP_Text, FractalState> fractals = new Dictionary<TMP_Text, FractalState>();

		private static readonly Dictionary<TMP_Text, int> wornFx = new Dictionary<TMP_Text, int>();

		private static readonly HashSet<TMP_Text> deadLabels = new HashSet<TMP_Text>();

		private static readonly int GlowColorId = Shader.PropertyToID("_GlowColor");

		private static readonly int GlowPowerId = Shader.PropertyToID("_GlowPower");

		private static readonly int UnderlayColorId = Shader.PropertyToID("_UnderlayColor");

		private static readonly int UnderlayOffsetXId = Shader.PropertyToID("_UnderlayOffsetX");

		private static readonly int UnderlayOffsetYId = Shader.PropertyToID("_UnderlayOffsetY");

		private static readonly int UnderlaySoftnessId = Shader.PropertyToID("_UnderlaySoftness");

		private const int MaxMotesPerLabel = 8;

		private const float PlateSizeScale = 1f;

		private static readonly Random rng = new Random(-1694607379);

		public static void Reset()
		{
			canvased.Clear();
			lastTick.Clear();
			foreach (MoteState value in motes.Values)
			{
				foreach (Mote item in value.live)
				{
					if ((Object)(object)item.img != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)item.img).gameObject);
					}
				}
				foreach (Image item2 in value.pool)
				{
					if ((Object)(object)item2 != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)item2).gameObject);
					}
				}
			}
			motes.Clear();
			wornFx.Clear();
			deadLabels.Clear();
			foreach (FractalState value2 in fractals.Values)
			{
				if ((Object)(object)value2.img != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value2.img).gameObject);
				}
				if ((Object)(object)value2.tex != (Object)null)
				{
					Object.Destroy((Object)(object)value2.tex);
				}
			}
			fractals.Clear();
			foreach (KeyValuePair<TMP_Text, Material> glowMat in glowMats)
			{
				if ((Object)(object)glowMat.Key == (Object)null && (Object)(object)glowMat.Value != (Object)null)
				{
					Object.Destroy((Object)(object)glowMat.Value);
				}
			}
			glowMats.Clear();
			chiselMat.Clear();
		}

		public static void Animate(UiKit.Label label, int fx, uint seed, float now, float dim = 1f)
		{
			if (label == null)
			{
				return;
			}
			TMP_Text tmp = label.Tmp;
			if ((Object)(object)tmp == (Object)null)
			{
				return;
			}
			if (fx < 0 || fx >= Table.Length)
			{
				if (wornFx.ContainsKey(tmp))
				{
					UndoFx(tmp);
				}
			}
			else
			{
				if (deadLabels.Contains(tmp) || (lastTick.TryGetValue(tmp, out var value) && now - value < 1f / 30f))
				{
					return;
				}
				lastTick[tmp] = now;
				if (wornFx.TryGetValue(tmp, out var value2) && value2 != fx)
				{
					UndoFx(tmp);
				}
				wornFx[tmp] = fx;
				try
				{
					AnimateInner(tmp, fx, seed, now, dim);
				}
				catch (Exception e)
				{
					GoreSystem.WarnThrottled("name fx", e);
					try
					{
						UndoFx(tmp);
					}
					catch
					{
					}
					deadLabels.Add(tmp);
				}
			}
		}

		private static void AnimateInner(TMP_Text tmp, int fx, uint seed, float now, float dim)
		{
			//IL_007e: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_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_00e8: 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_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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			if (canvased.Add(tmp) && (Object)(object)((Component)tmp).gameObject.GetComponent<Canvas>() == (Object)null)
			{
				((Component)tmp).gameObject.AddComponent<Canvas>();
			}
			EnsureGlow(tmp, fx);
			tmp.ForceMeshUpdate(false, false);
			TMP_TextInfo textInfo = tmp.textInfo;
			if (textInfo == null || textInfo.characterCount == 0)
			{
				return;
			}
			float num = (float)(seed % 977) * 0.013f;
			bool flag = PlateEffect(fx) && PlateReady(tmp);
			for (int i = 0; i < textInfo.characterCount; i++)
			{
				TMP_CharacterInfo val = textInfo.characterInfo[i];
				if (!val.isVisible)
				{
					continue;
				}
				Vector3[] vertices = textInfo.meshInfo[val.materialReferenceIndex].vertices;
				Color32[] colors = textInfo.meshInfo[val.materialReferenceIndex].colors32;
				GlyphFx(fx, i, textInfo.characterCount, now + num, seed, out var top, out var bottom, out var lift, out var lum);
				Color32 val2 = Scale(top, lum * dim);
				Color32 val3 = Scale(bottom, lum * dim);
				if (flag)
				{
					val2.a = 0;
					val3.a = 0;
				}
				GlyphShape(fx, i, textInfo.characterCount, now + num, out var sclX, out var sclY, out var skew);
				bool flag2 = sclX != 1f || sclY != 1f || skew != 0f;
				float num2 = 0f;
				float num3 = 0f;
				if (flag2)
				{
					num2 = (val.bottomLeft.x + val.topRight.x) * 0.5f;
					num3 = (val.bottomLeft.y + val.topRight.y) * 0.5f;
				}
				for (int j = 0; j < 4; j++)
				{
					int num4 = val.vertexIndex + j;
					colors[num4] = ((j == 1 || j == 2) ? val2 : val3);
					if (flag2)
					{
						float num5 = vertices[num4].x - num2;
						float num6 = vertices[num4].y - num3;
						vertices[num4].x = num2 + num5 * sclX + num6 * skew;
						vertices[num4].y = num3 + num6 * sclY;
					}
					vertices[num4].y += lift;
				}
			}
			tmp.UpdateVertexData((TMP_VertexDataUpdateFlags)17);
			StepMotes(tmp, fx, textInfo, now, now + num, dim);
			if (fx == 17)
			{
				StepChiselShadow(tmp, now + num);
			}
			if (PlateEffect(fx))
			{
				StepBackplate(tmp, fx, now + num, dim);
			}
		}

		private static void UndoFx(TMP_Text tmp)
		{
			wornFx.Remove(tmp);
			if (fractals.TryGetValue(tmp, out var value))
			{
				if ((Object)(object)value.img != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value.img).gameObject);
				}
				if ((Object)(object)value.tex != (Object)null)
				{
					Object.Destroy((Object)(object)value.tex);
				}
				fractals.Remove(tmp);
			}
			if (motes.TryGetValue(tmp, out var value2))
			{
				foreach (Mote item in value2.live)
				{
					if ((Object)(object)item.img != (Object)null)
					{
						((Behaviour)item.img).enabled = false;
						Object.Destroy((Object)(object)((Component)item.img).gameObject);
					}
				}
				foreach (Image item2 in value2.pool)
				{
					if ((Object)(object)item2 != (Object)null)
					{
						((Behaviour)item2).enabled = false;
						Object.Destroy((Object)(object)((Component)item2).gameObject);
					}
				}
				motes.Remove(tmp);
			}
			if (glowMats.TryGetValue(tmp, out var value3))
			{
				glowMats.Remove(tmp);
				chiselMat.Remove(tmp);
				if ((Object)(object)value3 != (Object)null)
				{
					if (value3.HasProperty(GlowPowerId))
					{
						value3.SetFloat(GlowPowerId, 0f);
					}
					value3.DisableKeyword("GLOW_ON");
					value3.DisableKeyword("UNDERLAY_ON");
				}
			}
			if ((Object)(object)tmp != (Object)null)
			{
				tmp.ForceMeshUpdate(false, false);
			}
		}

		private static bool PlateEffect(int fx)
		{
			if (fx != 13 && fx != 14 && fx != 18)
			{
				if (fx >= 33)
				{
					return fx <= 36;
				}
				return false;
			}
			return true;
		}

		private static bool PlateReady(TMP_Text tmp)
		{
			if (fractals.TryGetValue(tmp, out var value) && (Object)(object)value.img != (Object)null && (Object)(object)value.tex != (Object)null && value.plate != null)
			{
				return value.plate.letters > 0;
			}
			return false;
		}

		private static NamePlates.Painter PainterFor(int fx)
		{
			return fx switch
			{
				13 => NamePlates.Painter.Magma, 
				18 => NamePlates.Painter.Julia, 
				33 => NamePlates.Painter.Aurora, 
				34 => NamePlates.Painter.Reactor, 
				35 => NamePlates.Painter.Hive, 
				36 => NamePlates.Painter.Fire, 
				_ => NamePlates.Painter.VoidLens, 
			};
		}

		private static void StepBackplate(TMP_Text tmp, int fx, float t, float dim)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//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_0070: 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_00b9: 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_016f: 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_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: 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_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			if (!fractals.TryGetValue(tmp, out var value))
			{
				value = (fractals[tmp] = new FractalState());
				try
				{
					value.tex = new Texture2D(160, 40, (TextureFormat)4, false)
					{
						filterMode = (FilterMode)0
					};
					value.rgba = new byte[25600];
					GameObject val = new GameObject("namefxPlate");
					val.transform.SetParent(tmp.transform.parent, false);
					val.transform.SetSiblingIndex(tmp.transform.GetSiblingIndex());
					RawImage val2 = val.AddComponent<RawImage>();
					((Graphic)val2).raycastTarget = false;
					RectTransform rectTransform = ((Graphic)val2).rectTransform;
					rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
					rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
					rectTransform.pivot = new Vector2(0.5f, 0.5f);
					val2.texture = (Texture)(object)value.tex;
					value.img = val2;
				}
				catch
				{
					value.img = null;
				}
			}
			if ((Object)(object)value.img == (Object)null || (Object)(object)value.tex == (Object)null)
			{
				return;
			}
			string text = tmp.text;
			if (value.plate == null || value.srcText != text)
			{
				value.srcText = text;
				value.plate = NamePlates.Build(tmp.GetParsedText());
			}
			if (value.plate.letters == 0)
			{
				((Behaviour)value.img).enabled = false;
				return;
			}
			((Behaviour)value.img).enabled = true;
			Bounds textBounds = tmp.textBounds;
			if (((Bounds)(ref textBounds)).size.x > 1f && ((Bounds)(ref textBounds)).size.y > 1f)
			{
				float num = 1f * ((Bounds)(ref textBounds)).size.x / Mathf.Max(1f, ((float)value.plate.letters * 6f - 1f) * (float)value.plate.scale);
				float num2 = 1f * ((Bounds)(ref textBounds)).size.y / (7f * (float)value.plate.scale);
				RectTransform rectTransform2 = ((Graphic)value.img).rectTransform;
				rectTransform2.sizeDelta = new Vector2(160f * num, 40f * num2);
				((Transform)rectTransform2).localPosition = ((Transform)tmp.rectTransform).localPosition + new Vector3(((Bounds)(ref textBounds)).center.x, ((Bounds)(ref textBounds)).center.y + (20f - ((float)value.plate.yBase + 3.5f * (float)value.plate.scale)) * num2, 0f);
			}
			((Graphic)value.img).color = new Color(1f, 1f, 1f, dim);
			if (!(t < value.nextAt))
			{
				value.nextAt = t + 1f / 30f;
				NamePlates.Paint(value.plate, value.rgba, PainterFor(fx), t);
				value.tex.LoadRawTextureData(value.rgba);
				value.tex.Apply(false);
			}
		}

		private static uint Hash2(int x, int y)
		{
			int num = x * 374761393 + y * 668265263;
			int num2 = (num ^ (num >>> 13)) * 1274126177;
			return (uint)(num2 ^ (num2 >>> 16));
		}

		private static void StepChiselShadow(TMP_Text tmp, float t)
		{
			if (chiselMat.TryGetValue(tmp, out var value) && !((Object)(object)value == (Object)null))
			{
				value.SetFloat(UnderlayOffsetXId, 1.4f * Mathf.Cos(t * 0.9f));
				value.SetFloat(UnderlayOffsetYId, -0.8f - 0.7f * Mathf.Abs(Mathf.Sin(t * 0.9f)));
			}
		}

		private static void EnsureGlow(TMP_Text tmp, int fx)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: 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_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Table[fx].tier < 2 || glowMats.ContainsKey(tmp))
			{
				return;
			}
			glowMats[tmp] = null;
			try
			{
				Material fontMaterial = tmp.fontMaterial;
				if (!fontMaterial.HasProperty(GlowPowerId) || !fontMaterial.HasProperty(GlowColorId))
				{
					return;
				}
				glowMats[tmp] = fontMaterial;
				Color val = (Color)(fx switch
				{
					14 => new Color(0.45f, 0.1f, 0.85f), 
					13 => new Color(1f, 0.38f, 0.05f), 
					12 => new Color(0.9f, 0.65f, 0.12f), 
					16 => new Color(0.88f, 0.9f, 1f), 
					17 => new Color(0.75f, 0.6f, 0.35f), 
					18 => new Color(0.45f, 0.35f, 0.9f), 
					29 => new Color(1f, 0.85f, 0.5f), 
					30 => new Color(0.4f, 0.9f, 0.75f), 
					31 => new Color(0.8f, 0.12f, 0.1f), 
					32 => new Color(0.7f, 0.8f, 0.95f), 
					33 => new Color(0.3f, 0.9f, 0.7f), 
					34 => new Color(0.4f, 0.7f, 1f), 
					35 => new Color(0.5f, 0.2f, 0.8f), 
					36 => new Color(1f, 0.5f, 0.1f), 
					_ => new Color(0.55f, 0.85f, 1f), 
				});
				fontMaterial.EnableKeyword("GLOW_ON");
				fontMaterial.SetColor(GlowColorId, val);
				fontMaterial.SetFloat(GlowPowerId, 0.35f);
				if (fx == 17 && fontMaterial.HasProperty(UnderlayOffsetXId) && fontMaterial.HasProperty(UnderlayColorId))
				{
					fontMaterial.EnableKeyword("UNDERLAY_ON");
					fontMaterial.SetColor(UnderlayColorId, new Color(0f, 0f, 0f, 0.8f));
					if (fontMaterial.HasProperty(UnderlaySoftnessId))
					{
						fontMaterial.SetFloat(UnderlaySoftnessId, 0.3f);
					}
					chiselMat[tmp] = fontMaterial;
				}
			}
			catch
			{
			}
		}

		private static void StepMotes(TMP_Text tmp, int fx, TMP_TextInfo info, float now, float tFx, float dim)
		{
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			Tier tier = Table[fx].tier;
			if (tier == Tier.White)
			{
				return;
			}
			if (!motes.TryGetValue(tmp, out var value))
			{
				value = (motes[tmp] = new MoteState());
			}
			float num = tier switch
			{
				Tier.Red => 0.3f, 
				Tier.Green => 0.55f, 
				_ => 0.16f, 
			};
			if (now >= value.nextSpawnAt && value.live.Count < 8 && info.characterCount > 0)
			{
				value.nextSpawnAt = now + num * (0.7f + 0.6f * (float)rng.NextDouble());
				switch (fx)
				{
				case 11:
					SpawnArc(tmp, info, value);
					break;
				case 19:
					SpawnConstellation(tmp, info, value);
					break;
				case 24:
					SpawnRain(tmp, info, value);
					break;
				case 29:
					SpawnProminence(tmp, info, value);
					break;
				case 32:
					SpawnRazorCut(tmp, info, value, tFx);
					break;
				case 35:
					SpawnEyes(tmp, info, value);
					break;
				default:
					SpawnMote(tmp, fx, info, value, tFx);
					break;
				}
			}
			for (int num2 = value.live.Count - 1; num2 >= 0; num2--)
			{
				Mote mote = value.live[num2];
				mote.life -= 1f / 30f;
				if (mote.life <= 0f || (Object)(object)mote.img == (Object)null)
				{
					if ((Object)(object)mote.img != (Object)null)
					{
						((Behaviour)mote.img).enabled = false;
						value.pool.Push(mote.img);
					}
					value.live.RemoveAt(num2);
				}
				else
				{
					if (mote.attract != Vector2.zero)
					{
						Vector2 vel = mote.vel;
						Vector2 val = mote.attract - mote.pos;
						mote.vel = vel + ((Vector2)(ref val)).normalized * 4.6666665f;
					}
					mote.pos += mote.vel / 30f;
					float num3 = mote.life / mote.maxLife;
					((Graphic)mote.img).rectTransform.anchoredPosition = mote.pos;
					((Graphic)mote.img).color = new Color(mote.col.r, mote.col.g, mote.col.b, mote.col.a * num3 * dim);
				}
			}
		}

		private static void SpawnMote(TMP_Text tmp, int fx, TMP_TextInfo info, MoteState st, float tFx)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0651: Unknown result type (might be due to invalid IL or missing references)
			//IL_0656: Unknown result type (might be due to invalid IL or missing references)
			//IL_0658: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0711: Unknown result type (might be due to invalid IL or missing references)
			//IL_0665: Unknown result type (might be due to invalid IL or missing references)
			//IL_0667: Unknown result type (might be due to invalid IL or missing references)
			//IL_066c: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Unknown result type (might be due to invalid IL or missing references)
			//IL_0682: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Unknown result type (might be due to invalid IL or missing references)
			//IL_0687: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0582: Unknown result type (might be due to invalid IL or missing references)
			//IL_0868: Unknown result type (might be due to invalid IL or missing references)
			//IL_087d: Unknown result type (might be due to invalid IL or missing references)
			//IL_089b: Unknown result type (might be due to invalid IL or missing references)
			//IL_089d: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0794: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_0796: Unknown result type (might be due to invalid IL or missing references)
			//IL_0808: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_080d: Unknown result type (might be due to invalid IL or missing references)
			int characterCount = info.characterCount;
			int num = -1;
			if (fx == 6 || fx == 7)
			{
				float period = ((fx == 6) ? 4f : 5f);
				float num2 = ((fx == 6) ? 1.2f : 1.6f);
				float chance = ((fx == 6) ? 0.35f : 0.3f);
				int num3 = 0;
				for (int i = 0; i < characterCount; i++)
				{
					if (GlyphChance(tFx, i, period, chance, out var k) && k < num2 && rng.Next(++num3) == 0)
					{
						num = i;
					}
				}
			}
			if (num < 0)
			{
				num = rng.Next(characterCount);
			}
			TMP_CharacterInfo val = info.characterInfo[num];
			if (val.isVisible)
			{
				Vector2 val2 = Vector2.op_Implicit(val.topLeft + val.topRight) * 0.5f;
				Vector2 val3 = Vector2.op_Implicit(val.bottomLeft + val.bottomRight) * 0.5f;
				Vector2 val4 = (val2 + val3) * 0.5f;
				Vector2 attract = Vector2.zero;
				float num4 = 3f;
				Vector2 pos;
				Vector2 zero = default(Vector2);
				Color col = default(Color);
				float num6;
				switch (fx)
				{
				case 6:
					pos = val3;
					((Vector2)(ref zero))..ctor(0f, -26f);
					((Color)(ref col))..ctor(0.62f, 0.06f, 0.06f, 0.95f);
					num6 = 0.9f;
					break;
				case 7:
					pos = val3;
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 14f, -18f);
					((Color)(ref col))..ctor(0.25f, 0.95f, 0.1f, 0.9f);
					num6 = 0.7f;
					break;
				case 8:
					pos = val2;
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 12f, 30f);
					((Color)(ref col))..ctor(1f, 0.55f, 0.1f, 0.95f);
					num6 = 0.7f;
					num4 = 2.5f;
					break;
				case 9:
					pos = val4;
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 30f, 10f);
					((Color)(ref col))..ctor(0.85f, 0.95f, 1f, 0.9f);
					num6 = 0.45f;
					num4 = 2.5f;
					break;
				case 10:
					pos = val4;
					((Vector2)(ref zero))..ctor(-22f, 0f);
					((Color)(ref col))..ctor(0.35f, 0.32f, 0.45f, 0.5f);
					num6 = 0.6f;
					num4 = 5f;
					break;
				case 12:
					pos = val2 + new Vector2(0f, 2f);
					((Vector2)(ref zero))..ctor(0f, 8f);
					((Color)(ref col))..ctor(1f, 0.85f, 0.35f, 0.95f);
					num6 = 0.4f;
					num4 = 2.5f;
					break;
				case 13:
					pos = val4;
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 16f, 38f);
					((Color)(ref col))..ctor(1f, 0.45f, 0.06f, 0.95f);
					num6 = 0.9f;
					break;
				case 14:
					pos = val4 + new Vector2((float)(rng.NextDouble() - 0.5) * 60f, (float)(rng.NextDouble() - 0.5) * 34f);
					zero = Vector2.zero;
					attract = val4;
					((Color)(ref col))..ctor(0.6f, 0.2f, 1f, 0.9f);
					num6 = 0.8f;
					num4 = 2.5f;
					break;
				case 15:
					pos = val3;
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 10f, -14f);
					((Color)(ref col))..ctor(0.62f, 0.56f, 0.47f, 0.85f);
					num6 = 0.8f;
					num4 = 2.5f;
					break;
				case 16:
				{
					pos = val2;
					((Vector2)(ref zero))..ctor(0f, 6f);
					Color val5 = Color.HSVToRGB(Mathf.Repeat(tFx * 40f, 360f) / 360f, 0.7f, 1f);
					((Color)(ref col))..ctor(val5.r, val5.g, val5.b, 0.95f);
					num6 = 0.4f;
					num4 = 2.5f;
					break;
				}
				case 25:
					pos = val4 + new Vector2((float)(rng.NextDouble() - 0.5) * 6f, (float)(rng.NextDouble() - 0.5) * 6f);
					((Vector2)(ref zero))..ctor((rng.Next(2) == 0) ? 40f : (-40f), 0f);
					col = ((rng.Next(2) == 0) ? new Color(1f, 0.25f, 0.8f, 0.9f) : new Color(0.25f, 0.9f, 1f, 0.9f));
					num6 = 0.22f;
					num4 = 3f;
					break;
				case 26:
				{
					pos = val4 + new Vector2((float)(rng.NextDouble() - 0.5) * 14f, (float)(rng.NextDouble() - 0.5) * 10f);
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 20f, (float)(rng.NextDouble() - 0.5) * 20f);
					TMP_CharacterInfo val6 = info.characterInfo[(int)(tFx * 0.5f) * 5 % Mathf.Max(1, characterCount)];
					attract = (val6.isVisible ? (Vector2.op_Implicit(val6.topLeft + val6.bottomRight) * 0.5f) : val4);
					((Color)(ref col))..ctor(0.3f, 0.26f, 0.2f, 0.9f);
					num6 = 1.2f;
					num4 = 2f;
					break;
				}
				case 27:
					pos = val2;
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 16f, 22f);
					((Color)(ref col))..ctor(0.75f, 0.93f, 0.95f, 0.9f);
					num6 = 0.45f;
					num4 = 2.5f;
					break;
				case 30:
					pos = val4;
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * 8f, 13f);
					((Color)(ref col))..ctor(0.7f, 1f, 0.9f, 0.5f);
					num6 = 1.1f;
					num4 = 4f;
					break;
				case 36:
				{
					float num5 = Mathf.Repeat(tFx, 9f);
					bool flag = num5 >= 2f && num5 < 2.6f;
					pos = (flag ? val4 : val2);
					((Vector2)(ref zero))..ctor((float)(rng.NextDouble() - 0.5) * (flag ? 40f : 16f), flag ? 34f : 18f);
					col = (flag ? new Color(1f, 0.6f, 0.15f, 0.95f) : new Color(1f, 0.45f, 0.1f, 0.8f));
					num6 = (flag ? 0.8f : 0.6f);
					num4 = 2.5f;
					break;
				}
				default:
					return;
				}
				Image val7 = ((st.pool.Count > 0) ? st.pool.Pop() : NewMoteImage(tmp));
				if (!((Object)(object)val7 == (Object)null))
				{
					((Behaviour)val7).enabled = true;
					((Transform)((Graphic)val7).rectTransform).localRotation = Quaternion.identity;
					((Graphic)val7).rectTransform.sizeDelta = new Vector2(num4, num4);
					st.live.Add(new Mote
					{
						img = val7,
						pos = pos,
						vel = zero,
						attract = attract,
						life = num6,
						maxLife = num6,
						col = col
					});
				}
			}
		}

		private static void SpawnSegment(TMP_Text tmp, MoteState st, Vector2 a, Vector2 b, Color col, float life, float width, Vector2 vel = default(Vector2))
		{
			//IL_0033: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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)
			Image val = ((st.pool.Count > 0) ? st.pool.Pop() : NewMoteImage(tmp));
			if (!((Object)(object)val == (Object)null))
			{
				((Behaviour)val).enabled = true;
				Vector2 val2 = b - a;
				((Graphic)val).rectTransform.sizeDelta = new Vector2(((Vector2)(ref val2)).magnitude, width);
				((Transform)((Graphic)val).rectTransform).localRotation = Quaternion.Euler(0f, 0f, Mathf.Atan2(val2.y, val2.x) * 57.29578f);
				st.live.Add(new Mote
				{
					img = val,
					pos = (a + b) * 0.5f,
					vel = vel,
					life = life,
					maxLife = life,
					col = col
				});
			}
		}

		private static void SpawnArc(TMP_Text tmp, TMP_TextInfo info, MoteState st)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0109: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_012c: 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_013c: 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)
			int characterCount = info.characterCount;
			if (characterCount >= 2 && st.live.Count + 2 <= 8)
			{
				int num = rng.Next(characterCount - 1);
				TMP_CharacterInfo val = info.characterInfo[num];
				TMP_CharacterInfo val2 = info.characterInfo[num + 1];
				if (val.isVisible && val2.isVisible)
				{
					Vector2 val3 = Vector2.op_Implicit(val.topLeft + val.topRight) * 0.5f;
					Vector2 val4 = Vector2.op_Implicit(val2.topLeft + val2.topRight) * 0.5f;
					Vector2 val5 = (val3 + val4) * 0.5f + new Vector2((float)(rng.NextDouble() - 0.5) * 4f, 2f + (float)rng.NextDouble() * 5f);
					Color col = default(Color);
					((Color)(ref col))..ctor(0.8f, 0.95f, 1f, 0.95f);
					SpawnSegment(tmp, st, val3, val5, col, 0.13f, 1.4f);
					SpawnSegment(tmp, st, val5, val4, col, 0.13f, 1.4f);
				}
			}
		}

		private static void SpawnConstellation(TMP_Text tmp, TMP_TextInfo info, MoteState st)
		{
			//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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_0192: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			int characterCount = info.characterCount;
			if (characterCount < 1)
			{
				return;
			}
			if (characterCount >= 2 && rng.Next(2) == 0)
			{
				int num = rng.Next(characterCount);
				int num2 = rng.Next(characterCount);
				if (num == num2)
				{
					num2 = (num + 1) % characterCount;
				}
				TMP_CharacterInfo val = info.characterInfo[num];
				TMP_CharacterInfo val2 = info.characterInfo[num2];
				if (val.isVisible && val2.isVisible)
				{
					SpawnSegment(tmp, st, Vector2.op_Implicit(val.topLeft + val.topRight) * 0.5f, Vector2.op_Implicit(val2.topLeft + val2.topRight) * 0.5f, new Color(0.72f, 0.78f, 1f, 0.26f), 1.5f, 1f);
				}
				return;
			}
			TMP_CharacterInfo val3 = info.characterInfo[rng.Next(characterCount)];
			if (val3.isVisible)
			{
				Image val4 = ((st.pool.Count > 0) ? st.pool.Pop() : NewMoteImage(tmp));
				if (!((Object)(object)val4 == (Object)null))
				{
					((Behaviour)val4).enabled = true;
					((Transform)((Graphic)val4).rectTransform).localRotation = Quaternion.identity;
					((Graphic)val4).rectTransform.sizeDelta = new Vector2(2f, 2f);
					st.live.Add(new Mote
					{
						img = val4,
						pos = Vector2.op_Implicit(val3.topLeft + val3.topRight) * 0.5f + new Vector2(0f, 2f),
						vel = new Vector2(0f, 2f),
						life = 0.9f,
						maxLife = 0.9f,
						col = new Color(0.95f, 0.97f, 1f, 0.9f)
					});
				}
			}
		}

		private static void SpawnRain(TMP_Text tmp, TMP_TextInfo info, MoteState st)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00a3: 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)
			int characterCount = info.characterCount;
			if (characterCount >= 1)
			{
				TMP_CharacterInfo val = info.characterInfo[rng.Next(characterCount)];
				if (val.isVisible)
				{
					Vector2 val2 = Vector2.op_Implicit(val.topLeft + val.topRight) * 0.5f + new Vector2((float)(rng.NextDouble() - 0.5) * 8f, 5f);
					SpawnSegment(tmp, st, val2, val2 + new Vector2(0.6f, -3.5f), new Color(0.6f, 0.7f, 0.85f, 0.6f), 0.5f, 1f, new Vector2(4f, -46f));
				}
			}
		}

		private static void SpawnProminence(TMP_Text tmp, TMP_TextInfo info, MoteState st)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0109: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_012c: 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_013c: 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)
			int characterCount = info.characterCount;
			if (characterCount >= 2 && st.live.Count + 2 <= 8)
			{
				int num = rng.Next(characterCount - 1);
				TMP_CharacterInfo val = info.characterInfo[num];
				TMP_CharacterInfo val2 = info.characterInfo[num + 1];
				if (val.isVisible && val2.isVisible)
				{
					Vector2 val3 = Vector2.op_Implicit(val.topLeft + val.topRight) * 0.5f;
					Vector2 val4 = Vector2.op_Implicit(val2.topLeft + val2.topRight) * 0.5f;
					Vector2 val5 = (val3 + val4) * 0.5f + new Vector2((float)(rng.NextDouble() - 0.5) * 6f, 9f + (float)rng.NextDouble() * 5f);
					Color col = default(Color);
					((Color)(ref col))..ctor(1f, 0.75f, 0.3f, 0.9f);
					SpawnSegment(tmp, st, val3, val5, col, 0.5f, 1.6f);
					SpawnSegment(tmp, st, val5, val4, col, 0.5f, 1.6f);
				}
			}
		}

		private static void SpawnRazorCut(TMP_Text tmp, TMP_TextInfo info, MoteState st, float tFx)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0037: 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_003e: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_016f: 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_017a: 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_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			int characterCount = info.characterCount;
			if (characterCount < 2)
			{
				return;
			}
			if (Mathf.Repeat(tFx, 6f) < 0.25f)
			{
				TMP_CharacterInfo val = info.characterInfo[0];
				TMP_CharacterInfo val2 = info.characterInfo[characterCount - 1];
				if (val.isVisible && val2.isVisible)
				{
					SpawnSegment(tmp, st, Vector2.op_Implicit(val.bottomLeft) + new Vector2(-2f, -2f), Vector2.op_Implicit(val2.topRight) + new Vector2(2f, 2f), new Color(1f, 1f, 1f, 0.9f), 0.2f, 1.2f);
				}
				return;
			}
			TMP_CharacterInfo val3 = info.characterInfo[rng.Next(characterCount)];
			if (val3.isVisible)
			{
				Image val4 = ((st.pool.Count > 0) ? st.pool.Pop() : NewMoteImage(tmp));
				if (!((Object)(object)val4 == (Object)null))
				{
					((Behaviour)val4).enabled = true;
					((Transform)((Graphic)val4).rectTransform).localRotation = Quaternion.identity;
					((Graphic)val4).rectTransform.sizeDelta = new Vector2(2f, 2f);
					st.live.Add(new Mote
					{
						img = val4,
						pos = Vector2.op_Implicit(val3.topLeft + val3.topRight) * 0.5f,
						vel = Vector2.zero,
						life = 0.3f,
						maxLife = 0.3f,
						col = new Color(0.9f, 0.95f, 1f, 0.8f)
					});
				}
			}
		}

		private static void SpawnEyes(TMP_Text tmp, TMP_TextInfo info, MoteState st)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			int characterCount = info.characterCount;
			if (characterCount < 1 || st.live.Count + 2 > 8)
			{
				return;
			}
			TMP_CharacterInfo val = info.characterInfo[rng.Next(characterCount)];
			if (!val.isVisible)
			{
				return;
			}
			Vector2 val2 = Vector2.op_Implicit(val.topLeft + val.bottomRight) * 0.5f + new Vector2((float)(rng.NextDouble() - 0.5) * 20f, (float)(rng.NextDouble() - 0.5) * 16f);
			for (int i = 0; i < 2; i++)
			{
				Image val3 = ((st.pool.Count > 0) ? st.pool.Pop() : NewMoteImage(tmp));
				if ((Object)(object)val3 == (Object)null)
				{
					break;
				}
				((Behaviour)val3).enabled = true;
				((Transform)((Graphic)val3).rectTransform).localRotation = Quaternion.identity;
				((Graphic)val3).rectTransform.sizeDelta = new Vector2(1.8f, 1.8f);
				st.live.Add(new Mote
				{
					img = val3,
					pos = val2 + new Vector2((i == 0) ? (-1.8f) : 1.8f, 0f),
					vel = Vector2.zero,
					life = 1.6f,
					maxLife = 1.6f,
					col = new Color(0.9f, 0.86f, 0.5f, 0.95f)
				});
			}
		}

		private static Image NewMoteImage(TMP_Text tmp)
		{
			//IL_000b: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Image obj = UiKit.CreateImage("namefxMote", tmp.transform, Color.white);
				((Graphic)obj).raycastTarget = false;
				((Graphic)obj).rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				((Graphic)obj).rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				return obj;
			}
			catch
			{
				return null;
			}
		}

		private static void GlyphFx(int fx, int i, int n, float t, uint seed, out Color32 top, out Color32 bottom, out float lift, out float lum)
		{
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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_0115: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: 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_014a: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			GlyphCore(fx, i, n, t, seed, out var tint, out lift, out lum);
			switch (fx)
			{
			case 8:
			case 13:
			case 36:
				bottom = new Color32((byte)120, (byte)18, (byte)6, byte.MaxValue);
				top = tint;
				break;
			case 14:
				bottom = new Color32((byte)24, (byte)8, (byte)40, byte.MaxValue);
				top = tint;
				break;
			case 3:
			case 12:
				bottom = new Color32((byte)105, (byte)70, (byte)18, byte.MaxValue);
				top = tint;
				break;
			case 2:
			case 9:
			case 33:
				bottom = tint;
				top = new Color32((byte)235, (byte)245, byte.MaxValue, byte.MaxValue);
				break;
			case 7:
				bottom = new Color32((byte)150, byte.MaxValue, (byte)60, byte.MaxValue);
				top = Scale(tint, 0.8f);
				break;
			case 20:
				bottom = new Color32((byte)52, (byte)40, (byte)28, byte.MaxValue);
				top = tint;
				break;
			case 21:
				bottom = new Color32((byte)8, (byte)12, (byte)26, byte.MaxValue);
				top = tint;
				break;
			case 23:
				bottom = new Color32((byte)44, (byte)26, (byte)52, byte.MaxValue);
				top = tint;
				break;
			case 27:
				bottom = Scale(tint, 0.55f);
				top = tint;
				break;
			case 28:
				bottom = tint;
				top = new Color32(byte.MaxValue, (byte)206, (byte)240, byte.MaxValue);
				break;
			case 31:
				bottom = new Color32((byte)40, (byte)10, (byte)12, byte.MaxValue);
				top = tint;
				break;
			default:
				bottom = Scale(tint, 0.68f);
				top = Scale(tint, 1.12f);
				break;
			}
		}

		private static bool GlyphChance(float t, int i, float period, float chance, out float k)
		{
			float num = t + (float)(Hash2(i * 11, 71) % 997) / 997f * period;
			int num2 = (int)(num / period);
			k = num - (float)num2 * period;
			return (float)(Hash2(i * 29 + 1, num2 * 13) % 1000) < chance * 1000f;
		}

		private static bool GlitchHit(float t, int i, out int frame)
		{
			frame = (int)(t * 8f);
			return Hash2(i * 29 + 1, frame * 13) % 1000 < 55;
		}

		private static void GlyphCore(int fx, int i, int n, float t, uint seed, out Color32 tint, out float lift, out float lum)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_0122: 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_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: 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_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0718: Unknown result type (might be due to invalid IL or missing references)
			//IL_0735: Unknown result type (might be due to invalid IL or missing references)
			//IL_073a: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0824: Unknown result type (might be due to invalid IL or missing references)
			//IL_083e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0843: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0903: Unknown result type (might be due to invalid IL or missing references)
			//IL_0908: Unknown result type (might be due to invalid IL or missing references)
			//IL_094a: Unknown result type (might be due to invalid IL or missing references)
			//IL_094f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b8b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e3e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e43: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ef2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ef7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fd7: Unknown result type (might be due to invalid IL or missing references)
			//IL_1002: Unknown result type (might be due to invalid IL or missing references)
			//IL_1007: Unknown result type (might be due to invalid IL or missing references)
			//IL_1047: Unknown result type (might be due to invalid IL or missing references)
			//IL_104c: Unknown result type (might be due to invalid IL or missing references)
			//IL_10c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_10ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0795: Unknown result type (might be due to invalid IL or missing references)
			//IL_079a: Unknown result type (might be due to invalid IL or missing references)
			//IL_087b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0880: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd8: Unknown result type (might be due to invalid IL or missing references)
			//IL_10a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_10a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1144: Unknown result type (might be due to invalid IL or missing references)
			//IL_1149: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0614: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bcc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ec9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ece: Unknown result type (might be due to invalid IL or missing references)
			//IL_11bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_11c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1185: Unknown result type (might be due to invalid IL or missing references)
			//IL_118a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be9: Unknown result type (might be due to invalid IL or missing references)
			lift = 0f;
			lum = 1f;
			float k2;
			switch (fx)
			{
			default:
				tint = Umber;
				lum = 0.86f + 0.14f * Mathf.Sin(t * 1.8f - (float)i * 0.6f);
				break;
			case 1:
				tint = new Color32((byte)228, (byte)230, (byte)238, byte.MaxValue);
				lum = 0.78f + 0.22f * Mathf.Sin(t * 0.9f + (float)i * 1.7f);
				break;
			case 2:
				tint = FrostSkin;
				lum = (GlyphChance(t, i, 2f, 0.16f, out k2) ? 1.35f : 0.9f);
				break;
			case 3:
			{
				tint = Gold;
				float num16 = Mathf.Repeat(t / 6f, 1f) * (float)(n + 6) - 3f - (float)i;
				lum = 0.82f + 0.5f * Mathf.Max(0f, 1f - Mathf.Abs(num16) / 3f);
				break;
			}
			case 4:
				tint = Oil;
				lum = 0.85f + 0.3f * Mathf.Max(0f, Mathf.Sin(t * 0.7f + (float)i * 0.5f));
				break;
			case 5:
				tint = LunarGlow;
				lum = 0.72f + 0.28f * Mathf.Sin(t * 1.55f);
				break;
			case 6:
			{
				tint = Blood;
				float k;
				bool flag = GlyphChance(t, i, 4f, 0.35f, out k) && k < 1.2f;
				lum = (flag ? 0.6f : 0.92f);
				lift = (flag ? (-1.6f * k / 1.2f) : 0f);
				break;
			}
			case 7:
			{
				tint = AcidPulse;
				float k5;
				bool flag2 = GlyphChance(t, i, 5f, 0.3f, out k5) && k5 < 1.6f;
				lum = (flag2 ? (0.55f + 0.45f * (k5 / 1.6f)) : 0.88f);
				lift = (flag2 ? (-1.2f * (1f - k5 / 1.6f)) : 0f);
				break;
			}
			case 8:
				tint = EmberGlow;
				lum = 0.7f + 0.2f * Mathf.Sin(t * 2.1f + (float)i * 2.3f);
				if (Hash2(i * 17 + 1, (int)(t * 5.5f) * 13) % 1000 < 30)
				{
					lum = 1.5f;
				}
				break;
			case 9:
			{
				tint = FrostSkin;
				if (GlyphChance(t, i, 6f, 0.45f, out var k6) && k6 < 0.4f)
				{
					lum = 1.45f;
					lift = (((i & 1) == 0) ? 1.2f : (-1.2f));
				}
				else
				{
					lum = 0.9f;
				}
				break;
			}
			case 10:
				tint = new Color32((byte)80, (byte)76, (byte)92, byte.MaxValue);
				lift = 1.4f * Mathf.Sin(t * 2f - (float)i * 0.9f);
				lum = 0.8f + 0.2f * Mathf.Sin(t * 2f - (float)i * 0.9f - 0.8f);
				break;
			case 11:
			{
				tint = ArcGlow;
				lum = 0.8f;
				if (Hash2(i * 23 + 1, (int)(t * 6.7f) * 7) % 1000 < 50)
				{
					lift = ((((int)(t * 60f) & 1) == 0) ? 1.8f : (-1.8f));
					lum = 1.4f;
				}
				float num7 = Mathf.Repeat(t, 6f) * (float)(n + 4) / 0.3f - (float)i;
				if (num7 > 0f && num7 < 2f)
				{
					lum = 1.5f;
				}
				break;
			}
			case 12:
			{
				tint = Gold;
				float num2 = Mathf.Repeat(t / 4f, 1f) * (float)(n + 4) - 2f - (float)i;
				lum = 0.85f + 0.55f * Mathf.Max(0f, 1f - Mathf.Abs(num2) / 2f);
				if (Mathf.Repeat(t, 6f) < 0.5f)
				{
					lum = 1.5f;
				}
				break;
			}
			case 13:
			{
				tint = EmberGlow;
				lum = 0.75f + 0.2f * Mathf.Sin(t * 1.9f + (float)i * 1.1f);
				float num18 = Mathf.Repeat(t, 5f) * (float)(n + 6) / 0.8f - (float)i;
				if (num18 > 0f && num18 < 3f)
				{
					lift = 2.4f * Mathf.Sin(num18 / 3f * MathF.PI);
					lum = 1.4f;
				}
				break;
			}
			case 14:
			{
				tint = VoidGlow;
				lum = 0.8f + 0.2f * Mathf.Sin(t * 1.4f + (float)i * 0.8f);
				if (GlyphChance(t, i, 2.2f, 0.3f, out var k3) && k3 < 0.5f)
				{
					lift = -1.5f * Mathf.Sin(k3 / 0.5f * MathF.PI);
					lum = 0.6f;
				}
				if (Mathf.Repeat(t, 7f) < 0.4f)
				{
					tint = new Color32((byte)16, (byte)8, (byte)24, byte.MaxValue);
					lum = 1f;
				}
				break;
			}
			case 15:
			{
				tint = new Color32((byte)152, (byte)140, (byte)124, byte.MaxValue);
				lum = 0.86f + 0.1f * Mathf.Sin(t * 1.5f + (float)i * 0.7f);
				float num6 = Mathf.Repeat(t, 5f) * (float)(n + 4) / 0.5f - (float)i;
				if (num6 > 0f && num6 < 2f)
				{
					lift = (((i & 1) == 0) ? 1.3f : (-1.3f)) * (1f - num6 * 0.5f);
					lum = 1.2f;
				}
				break;
			}
			case 16:
			{
				float num3 = Mathf.Repeat(t / 4f, 1f) * (float)(n + 6) - 3f - (float)i;
				float num4 = Mathf.Max(0f, 1f - Mathf.Abs(num3) / 2.5f);
				tint = HueMix(new Color32((byte)212, (byte)214, (byte)224, byte.MaxValue), t * 40f + (float)i * 9f, num4 * 0.8f);
				lum = 0.85f + 0.55f * num4;
				if (Mathf.Repeat(t, 7f) < 0.4f)
				{
					tint = HueMix(new Color32((byte)220, (byte)222, (byte)232, byte.MaxValue), t * 320f + (float)i * 24f, 0.85f);
					lum = 1.35f;
				}
				break;
			}
			case 17:
			{
				tint = new Color32((byte)196, (byte)168, (byte)122, byte.MaxValue);
				float num5 = t * 1.6f - (float)i * 0.55f;
				lum = 0.82f + 0.28f * Mathf.Max(0f, Mathf.Sin(num5 + 0.6f));
				lift = 1.1f * Mathf.Sin(num5);
				break;
			}
			case 18:
				tint = HueMix(new Color32((byte)216, (byte)210, (byte)240, byte.MaxValue), t * 25f + (float)i * 12f, 0.25f);
				lum = 0.9f;
				if (Mathf.Repeat(t, 7f) < 0.3f)
				{
					tint = new Color32((byte)232, (byte)238, byte.MaxValue, byte.MaxValue);
					lum = 1.25f;
				}
				break;
			case 19:
				tint = new Color32((byte)202, (byte)212, (byte)238, byte.MaxValue);
				lum = 0.8f + 0.2f * Mathf.Sin(t * 1.1f + (float)i * 2.1f);
				if (GlyphChance(t, i, 2.5f, 0.15f, out k2))
				{
					lum = 1.3f;
				}
				break;
			case 20:
			{
				tint = new Color32((byte)104, (byte)158, (byte)88, byte.MaxValue);
				float num20 = Mathf.PingPong(t * 0.55f, (float)n + 3f);
				lum = 0.76f + 0.22f * Mathf.Clamp01(num20 - (float)i);
				break;
			}
			case 21:
			{
				tint = new Color32((byte)40, (byte)58, (byte)98, byte.MaxValue);
				lum = 0.74f + 0.16f * Mathf.Sin(t * 1.1f);
				if (GlyphChance(t, i, 4f, 0.12f, out var k7) && k7 < 2.5f)
				{
					tint = new Color32((byte)70, (byte)195, (byte)190, byte.MaxValue);
					lum = 1.05f;
				}
				break;
			}
			case 22:
			{
				uint num12 = Hash2(i * 13, (int)(seed % 97));
				tint = (((num12 & 1) == 0) ? new Color32((byte)152, (byte)84, (byte)48, byte.MaxValue) : new Color32((byte)120, (byte)96, (byte)62, byte.MaxValue));
				float num13 = Mathf.Repeat(t / 8f, 1f) * (float)(n + 6) - 3f - (float)i;
				lum = 0.84f + ((((num12 >> 1) & 1) == 0) ? 0.34f : 0.18f) * Mathf.Max(0f, 1f - Mathf.Abs(num13) / 3f);
				break;
			}
			case 23:
			{
				float num9 = ((n > 1) ? ((float)i / (float)(n - 1)) : 0f);
				tint = HueMix(new Color32((byte)150, (byte)110, (byte)120, byte.MaxValue), 20f + 265f * num9 + 18f * Mathf.Sin(t * 0.3f), 0.7f);
				lum = 0.84f + 0.1f * Mathf.Sin(t * 0.7f + num9 * 2f);
				break;
			}
			case 24:
			{
				tint = new Color32((byte)112, (byte)120, (byte)136, byte.MaxValue);
				lum = 0.78f + 0.12f * Mathf.Sin(t * 0.9f + (float)i * 0.4f);
				int num8 = (int)(t / 4.5f) * 11 % Mathf.Max(1, n);
				if (Mathf.Repeat(t, 4.5f) < 0.15f && Mathf.Abs(i - num8) <= 1)
				{
					tint = new Color32((byte)202, (byte)208, (byte)224, byte.MaxValue);
					lum = 1.35f;
				}
				break;
			}
			case 25:
			{
				tint = new Color32((byte)206, (byte)214, (byte)220, byte.MaxValue);
				lum = 0.9f;
				if (GlitchHit(t, i, out var frame))
				{
					tint = (((Hash2(i * 5, frame) & 1) == 0) ? new Color32(byte.MaxValue, (byte)60, (byte)200, byte.MaxValue) : new Color32((byte)60, (byte)230, byte.MaxValue, byte.MaxValue));
					lum = 1.3f;
					lift = (((Hash2(i * 9, frame) & 1) == 0) ? 1.5f : (-1.5f));
				}
				break;
			}
			case 26:
				tint = new Color32((byte)76, (byte)68, (byte)54, byte.MaxValue);
				lum = 0.82f + 0.12f * Mathf.Sin(t * 1.7f + (float)i * 1.3f);
				break;
			case 27:
			{
				tint = new Color32((byte)56, (byte)142, (byte)152, byte.MaxValue);
				float num19 = t * 2f - (float)i * 0.5f;
				lift = 1.8f * Mathf.Sin(num19);
				lum = 0.85f + 0.1f * Mathf.Sin(num19 - 0.5f);
				if (Mathf.Sin(num19) > 0.85f)
				{
					tint = new Color32((byte)214, (byte)240, (byte)244, byte.MaxValue);
					lum = 1.25f;
				}
				break;
			}
			case 28:
			{
				tint = new Color32(byte.MaxValue, (byte)74, (byte)192, byte.MaxValue);
				lum = 0.95f;
				if (GlyphChance(t, i, 5f, 0.22f, out var k4) && k4 < 0.6f)
				{
					lum = ((((int)(t * 40f) & 3) == 0) ? 0.55f : 0.88f);
				}
				break;
			}
			case 29:
				tint = new Color32(byte.MaxValue, (byte)238, (byte)196, byte.MaxValue);
				lum = 0.86f + 0.14f * Mathf.Sin(t * 1.7f + (float)i * 0.35f);
				if (Mathf.Repeat(t, 6f) < 0.3f)
				{
					lum = 1.45f;
				}
				break;
			case 30:
			{
				tint = new Color32((byte)172, (byte)234, (byte)214, byte.MaxValue);
				lum = 0.7f + 0.2f * Mathf.Sin(t * 0.8f + (float)i * 1.9f);
				float num17 = Mathf.Repeat(t, 6f);
				if (num17 < 0.4f)
				{
					lum = 0.6f;
					lift = 1.2f * Mathf.Sin(num17 / 0.4f * MathF.PI);
				}
				break;
			}
			case 31:
			{
				tint = new Color32((byte)186, (byte)42, (byte)42, byte.MaxValue);
				float num14 = Mathf.Repeat(t / 6f, 1f) * (float)(n + 7) - 3.5f;
				lum = 0.95f - 0.5f * Mathf.Max(0f, 1f - Mathf.Abs(num14 - (float)i) / 2.5f);
				float num15 = Mathf.Abs(num14 - (float)i);
				if (num15 > 2.5f && num15 < 3.5f)
				{
					tint = new Color32((byte)240, (byte)122, (byte)60, byte.MaxValue);
					lum = 1.3f;
				}
				break;
			}
			case 32:
			{
				tint = new Color32((byte)206, (byte)216, (byte)226, byte.MaxValue);
				float num10 = Mathf.Repeat(t / 3.5f, 1f) * (float)(n + 4) - 2f - (float)i;
				float num11 = (float)(n + 4) * (1f - Mathf.Repeat(t / 5f, 1f)) - 2f - (float)i;
				lum = 0.82f + 0.5f * Mathf.Max(Mathf.Max(0f, 1f - Mathf.Abs(num10) / 1.5f), Mathf.Max(0f, 1f - Mathf.Abs(num11) / 1.5f));
				if (Mathf.Repeat(t, 6f) < 0.25f)
				{
					lift = ((i < (int)(t / 6f) * 17 % Mathf.Max(1, n)) ? 1.4f : (-1.4f));
					lum = 1.2f;
				}
				break;
			}
			case 33:
				tint = HueMix(FrostSkin, 120f + 45f * Mathf.Sin(t * 0.5f + (float)i * 0.35f), 0.4f);
				lum = 0.88f + 0.12f * Mathf.Sin(t * 0.9f + (float)i * 0.6f);
				break;
			case 34:
				tint = new Color32((byte)205, (byte)220, (byte)240, byte.MaxValue);
				lum = 0.8f + 0.15f * Mathf.Sin(t * 2.2f + (float)i * 0.8f);
				if (Mathf.Repeat(t, 6f) < 0.35f)
				{
					tint = new Color32((byte)225, (byte)240, byte.MaxValue, byte.MaxValue);
					lum = 1.4f;
				}
				break;
			case 35:
				tint = new Color32((byte)190, (byte)162, (byte)218, byte.MaxValue);
				lum = 0.82f + 0.12f * Mathf.Sin(t * 1.2f + (float)i * 0.9f);
				if (Mathf.Repeat(t, 7f) < 0.3f)
				{
					lift = (((i & 1) == 0) ? 0.8f : (-0.8f));
				}
				break;
			case 36:
			{
				float num = Mathf.Repeat(t, 9f);
				if (num < 2f)
				{
					tint = new Color32((byte)72, (byte)40, (byte)28, byte.MaxValue);
					lum = 0.9f - 0.2f * (num / 2f);
				}
				else if (num < 2.4f)
				{
					tint = new Color32(byte.MaxValue, (byte)232, (byte)150, byte.MaxValue);
					lum = 1.5f;
					lift = 2.2f * Mathf.Sin((num - 2f) / 0.4f * MathF.PI);
				}
				else
				{
					tint = EmberGlow;
					lum = 0.78f + 0.18f * Mathf.Sin(t * 2f + (float)i * 1.1f);
				}
				break;
			}
			}
		}

		private static void GlyphShape(int fx, int i, int n, float t, out float sclX, out float sclY, out float skew)
		{
			sclX = 1f;
			sclY = 1f;
			skew = 0f;
			switch (fx)
			{
			case 14:
			{
				if (GlyphChance(t, i, 2.2f, 0.3f, out var k) && k < 0.5f)
				{
					sclX = (sclY = 1f - 0.35f * Mathf.Sin(k / 0.5f * MathF.PI));
				}
				for (int j = i - 3; j <= i + 3; j++)
				{
					if (j != i && j >= 0 && j < n && GlyphChance(t, j, 2.2f, 0.3f, out var k2) && k2 < 0.5f)
					{
						skew += Mathf.Clamp(-0.1f * Mathf.Sin(k2 / 0.5f * MathF.PI) / (float)(i - j), -0.08f, 0.08f);
					}
				}
				skew = Mathf.Clamp(skew, -0.1f, 0.1f);
				break;
			}
			case 17:
			{
				float num3 = t * 1.6f - (float)i * 0.55f;
				skew = 0.16f * Mathf.Sin(num3);
				sclY = 1f + 0.09f * Mathf.Sin(num3);
				break;
			}
			case 18:
			{
				float num2 = Mathf.Repeat(t, 7f);
				if (num2 < 0.3f)
				{
					sclX = (sclY = 1f + 0.06f * Mathf.Sin(num2 / 0.3f * MathF.PI));
				}
				break;
			}
			case 25:
			{
				if (GlitchHit(t, i, out var _))
				{
					sclX = 1.35f;
				}
				break;
			}
			case 36:
			{
				float num = Mathf.Repeat(t, 9f);
				if (num >= 2f && num < 2.4f)
				{
					sclX = (sclY = 1f + 0.12f * Mathf.Sin((num - 2f) / 0.4f * MathF.PI));
				}
				break;
			}
			}
		}

		private static Color32 HueMix(Color32 baseCol, float hueDeg, float strength)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0042: 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_005c: 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)
			Color val = Color.HSVToRGB(Mathf.Repeat(hueDeg, 360f) / 360f, 0.75f, 1f);
			return new Color32((byte)Mathf.Lerp((float)(int)baseCol.r, val.r * 255f, strength), (byte)Mathf.Lerp((float)(int)baseCol.g, val.g * 255f, strength), (byte)Mathf.Lerp((float)(int)baseCol.b, val.b * 255f, strength), byte.MaxValue);
		}

		private static Color32 Scale(Color32 c, float f)
		{
			//IL_0017: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			f = Mathf.Clamp(f, 0f, 1.6f);
			return new Color32((byte)Mathf.Min(255f, (float)(int)c.r * f), (byte)Mathf.Min(255f, (float)(int)c.g * f), (byte)Mathf.Min(255f, (float)(int)c.b * f), c.a);
		}
	}
	internal static class NamePlates
	{
		public enum Painter
		{
			Magma,
			VoidLens,
			Julia,
			Aurora,
			Reactor,
			Hive,
			Fire
		}

		public class Plate
		{
			public readonly byte[] mask = new byte[6400];

			public byte[] heat;

			public int x0;

			public int yBase;

			public int scale = 2;

			public int letters;
		}

		public const int W = 160;

		public const int H = 40;

		private static readonly byte[] Font = new byte[259]
		{
			14, 17, 17, 31, 17, 17, 17, 30, 17, 17,
			30, 17, 17, 30, 14, 17, 16, 16, 16, 17,
			14, 30, 17, 17, 17, 17, 17, 30, 31, 16,
			16, 30, 16, 16, 31, 31, 16, 16, 30, 16,
			16, 16, 14, 17, 16, 23, 17, 17, 15, 17,
			17, 17, 31, 17, 17, 17, 14, 4, 4, 4,
			4, 4, 14, 7, 2, 2, 2, 2, 18, 12,
			17, 18, 20, 24, 20, 18, 17, 16, 16, 16,
			16, 16, 16, 31, 17, 27, 21, 21, 17, 17,
			17, 17, 25, 21, 19, 17, 17, 17, 14, 17,
			17, 17, 17, 17, 14, 30, 17, 17, 30, 16,
			16, 16, 14, 17, 17, 17, 21, 18, 13, 30,
			17, 17, 30, 20, 18, 17, 15, 16, 16, 14,
			1, 1, 30, 31, 4, 4, 4, 4, 4, 4,
			17, 17, 17, 17, 17, 17, 14, 17, 17, 17,
			17, 17, 10, 4, 17, 17, 17, 21, 21, 21,
			10, 17, 17, 10, 4, 10, 17, 17, 17, 17,
			10, 4, 4, 4, 4, 31, 1, 2, 4, 8,
			16, 31, 14, 17, 19, 21, 25, 17, 14, 4,
			12, 4, 4, 4, 4, 14, 14, 17, 1, 2,
			4, 8, 31, 31, 2, 4, 2, 1, 17, 14,
			2, 6, 10, 18, 31, 2, 2, 31, 16, 30,
			1, 1, 17, 14, 6, 8, 16, 30, 17, 17,
			14, 31, 1, 2, 4, 8, 8, 8, 14, 17,
			17, 14, 17, 17, 14, 14, 17, 17, 15, 1,
			2, 12, 31, 17, 17, 17, 17, 17, 31
		};

		private const float PI = MathF.PI;

		private static int FontIndex(char c)
		{
			if (c >= 'A' && c <= 'Z')
			{
				return c - 65;
			}
			if (c >= '0' && c <= '9')
			{
				return 26 + c - 48;
			}
			if (c == ' ')
			{
				return -1;
			}
			return 36;
		}

		public static Plate Build(string name)
		{
			Plate plate = new Plate();
			if (string.IsNullOrEmpty(name))
			{
				return plate;
			}
			string text = name.ToUpperInvariant();
			int num = Math.Min(text.Length, 25);
			if (num <= 0)
			{
				return plate;
			}
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				if (FontIndex(text[i]) == 36)
				{
					num2++;
				}
			}
			if (num2 * 2 > num)
			{
				return plate;
			}
			int num3 = 152 / (num * 6);
			plate.scale = ((num3 < 1) ? 1 : ((num3 > 4) ? 4 : num3));
			plate.letters = num;
			plate.x0 = (160 - (num * 6 - 1) * plate.scale) / 2;
			plate.yBase = 5;
			for (int j = 0; j < num; j++)
			{
				int num4 = FontIndex(text[j]);
				if (num4 < 0)
				{
					continue;
				}
				for (int k = 0; k < 7; k++)
				{
					int num5 = Font[num4 * 7 + k];
					int num6 = plate.yBase + (6 - k) * plate.scale;
					for (int l = 0; l < 5; l++)
					{
						if ((num5 & (16 >> l)) == 0)
						{
							continue;
						}
						int num7 = plate.x0 + (j * 6 + l) * plate.scale;
						for (int m = 0; m < plate.scale; m++)
						{
							for (int n = 0; n < plate.scale; n++)
							{
								int num8 = num7 + n;
								int num9 = num6 + m;
								if (num8 >= 0 && num8 < 160 && num9 >= 0 && num9 < 40)
								{
									plate.mask[num9 * 160 + num8] = (byte)(j + 1);
								}
							}
						}
					}
				}
			}
			return plate;
		}

		private static byte MaskAt(Plate p, int x, int y)
		{
			if (x >= 0 && x < 160 && y >= 0 && y < 40)
			{
				return p.mask[y * 160 + x];
			}
			return 0;
		}

		public static void Paint(Plate p, byte[] rgba, Painter painter, float t)
		{
			switch (painter)
			{
			case Painter.Magma:
				PaintMagma(p, rgba, t);
				break;
			case Painter.VoidLens:
				PaintVoidLens(p, rgba, t);
				break;
			case Painter.Julia:
				PaintJulia(p, rgba, t);
				break;
			case Painter.Aurora:
				PaintAurora(p, rgba, t);
				break;
			case Painter.Reactor:
				PaintReactor(p, rgba, t);
				break;
			case Painter.Hive:
				PaintHive(p, rgba, t);
				break;
			default:
				PaintFire(p, rgba, t);
				break;
			}
		}

		private static void PaintMagma(Plate p, byte[] rgba, float t)
		{
			float num = Repeat(t, 5f);
			for (int i = 0; i < 40; i++)
			{
				for (int j = 0; j < 160; j++)
				{
					int num2 = i * 160 + j;
					if (p.mask[num2] == 0)
					{
						Clear(rgba, num2);
						continue;
					}
					float num3 = Sin((float)j * 0.14f + 3f * Sin((float)i * 0.2f + t * 0.8f)) + Sin((float)i * 0.31f - t * 0.6f);
					float num4 = 0.42f + 0.26f * num3;
					float num5 = num * 190f / 0.8f - (float)j;
					if (num5 > 0f && num5 < 14f)
					{
						num4 += 0.55f * (1f - num5 / 14f);
					}
					num4 = Clamp01(num4);
					byte r = (byte)(110f + 145f * num4);
					byte g = (byte)(18f + 160f * num4);
					byte b = (byte)(5f + 60f * num4);
					if (num3 > 1.15f)
					{
						r = byte.MaxValue;
						g = 226;
						b = 130;
					}
					Set(rgba, num2, r, g, b, byte.MaxValue);
				}
			}
		}

		private static void PaintVoidLens(Plate p, byte[] rgba, float t)
		{
			float num = 160f * (0.5f + 0.33f * Sin(t * 0.31f));
			float num2 = 40f * (0.5f + 0.28f * Sin(t * 0.23f + 1.7f));
			bool flag = Repeat(t, 7f) < 0.4f;
			for (int i = 0; i < 40; i++)
			{
				for (int j = 0; j < 160; j++)
				{
					int i2 = i * 160 + j;
					float num3 = (float)j - num;
					float num4 = (float)i - num2;
					float num5 = (float)Math.Sqrt(num3 * num3 + num4 * num4) + 0.001f;
					if (num5 < 9f)
					{
						Clear(rgba, i2);
						continue;
					}
					float num6 = 150f / (num5 + 6f);
					if (num6 > 5.5f)
					{
						num6 = 5.5f;
					}
					int num7 = (int)((float)j + num3 / num5 * num6);
					int num8 = (int)((float)i + num4 / num5 * num6);
					if (MaskAt(p, num7, num8) == 0)
					{
						Clear(rgba, i2);
						continue;
					}
					float num9 = 1f - Abs(num5 - 12f) / 3.5f;
					float num10 = 0.7f + 0.3f * Sin(t * 1.4f + (float)j * 0.05f);
					byte b;
					byte b2;
					byte b3;
					if (flag)
					{
						b = 20;
						b2 = 10;
						b3 = 30;
					}
					else
					{
						b = (byte)(118f * num10);
						b2 = (byte)(48f * num10);
						b3 = (byte)(188f * num10);
						if (Hash(num7 * 3 + (int)(t * 0.4f), num8 * 3) % 17 == 0)
						{
							b = 225;
							b2 = 215;
							b3 = byte.MaxValue;
						}
					}
					if (num9 > 0f)
					{
						b = (byte)Min(255, b + (int)(120f * num9));
						b2 = (byte)Min(255, b2 + (int)(70f * num9));
						b3 = (byte)Min(255, b3 + (int)(90f * num9));
					}
					Set(rgba, i2, b, b2, b3, byte.MaxValue);
				}
			}
		}

		private static void PaintJulia(Plate p, byte[] rgba, float t)
		{
			float num = Sin(Repeat(t, 7f) / 7f * MathF.PI);
			float num2 = 10f * num * num * num * num * num * num;
			float num3 = 0.7885f * Sin(t * 0.35f + MathF.PI / 2f);
			float num4 = 0.7885f * Sin(t * 0.35f);
			float num5 = 0.017708333f;
			for (int i = 0; i < 40; i++)
			{
				for (int j = 0; j < 160; j++)
				{
					int i2 = i * 160 + j;
					float num6 = (float)j + num2 * Sin((float)i * 0.3f + t * 1.1f + 2f * Sin((float)j * 0.17f + t * 0.6f));
					float num7 = (float)i + num2 * Sin((float)j * 0.23f - t * 0.9f);
					if (MaskAt(p, (int)num6, (int)num7) == 0)
					{
						Clear(rgba, i2);
						continue;
					}
					float num8 = ((float)j - 80f) * num5;
					float num9 = ((float)i - 20f) * num5;
					int k;
					for (k = 0; k < 20; k++)
					{
						if (!(num8 * num8 + num9 * num9 < 4f))
						{
							break;
						}
						float num10 = num8 * num8 - num9 * num9 + num3;
						num9 = 2f * num8 * num9 + num4;
						num8 = num10;
					}
					float num11 = (float)k / 20f;
					HsvToRgb((0.78f - 0.28f * num11) * 360f, 0.8f - 0.35f * num11, 0.5f + 0.5f * num11, out var r, out var g, out var b);
					Set(rgba, i2, r, g, b, byte.MaxValue);
				}
			}
		}

		private static void PaintAurora(Plate p, byte[] rgba, float t)
		{
			float num = Repeat(t, 7f);
			float num2 = 1f + ((num < 0.8f) ? (0.6f * (1f - num / 0.8f)) : 0f);
			float num3 = 7f * (float)p.scale;
			for (int i = 0; i < 160; i++)
			{
				float num4 = (0.5f + 0.5f * Sin((float)i * 0.13f + t * 1.1f)) * (0.5f + 0.5f * Sin((float)i * 0.031f - t * 0.4f)) * num2;
				float h = Repeat(0.38f - 0.14f * Sin((float)i * 0.07f + t * 0.2f), 1f) * 360f;
				for (int j = 0; j < 40; j++)
				{
					int num5 = j * 160 + i;
					if (p.mask[num5] == 0)
					{
						Clear(rgba, num5);
						continue;
					}
					float num6 = 0.5f + 0.5f * Clamp01((float)(j - p.yBase) / num3);
					float num7 = Clamp01(0.28f + 0.85f * num4) * num6;
					HsvToRgb(h, 0.8f, 0.22f + 0.78f * num7, out var r, out var g, out var b);
					if (num7 < 0.3f && Hash(i, j + (int)(t * 0.6f)) % 37 == 0)
					{
						r = 220;
						g = 225;
						b = 235;
					}
					Set(rgba, num5, r, g, b, byte.MaxValue);
				}
			}
		}

		private static void PaintReactor(Plate p, byte[] rgba, float t)
		{
			float num = ((Repeat(t, 6f) < 0.35f) ? 1.8f : 1f);
			int b = 6 * p.scale;
			for (int i = 0; i < 40; i++)
			{
				for (int j = 0; j < 160; j++)
				{
					int i2 = i * 160 + j;
					int num2 = ((p.letters > 0) ? ((j - p.x0) / Max(1, b)) : 0);
					num2 = ((num2 >= 0) ? ((num2 >= p.letters) ? (p.letters - 1) : num2) : 0);
					float num3 = (float)(p.x0 + (num2 * 6 + 2) * p.scale) + (float)p.scale * 0.5f;
					float num4 = (float)p.yBase + 3.5f * (float)p.scale;
					float num5 = (float)j - num3;
					float num6 = (float)i - num4;
					float num7 = (float)Math.Sqrt(num5 * num5 + num6 * num6) + 0.001f;
					float a = num7 * 0.7f - t * 4f;
					float num8 = Sin(a) * 1.6f * num;
					if (MaskAt(p, (int)((float)j + num5 / num7 * num8), (int)((float)i + num6 / num7 * num8)) == 0)
					{
						Clear(rgba, i2);
						continue;
					}
					float num9 = 0.55f + 0.45f * Sin(a);
					byte r = (byte)Min(255, (int)(30f + 100f * num9 * num));
					byte g = (byte)Min(255, (int)(120f + 100f * num9));
					byte b2 = (byte)Min(255, (int)(200f + 55f * num9));
					if (num > 1f && num9 > 0.8f)
					{
						r = 235;
						g = 245;
						b2 = byte.MaxValue;
					}
					Set(rgba, i2, r, g, b2, byte.MaxValue);
				}
			}
		}

		private static void PaintHive(Plate p, byte[] rgba, float t)
		{
			float num = Repeat(t, 7f);
			float num2 = ((num < 0.5f) ? Sin(num / 0.5f * MathF.PI) : 0f);
			float num3 = 1.4f + 1.6f * (0.5f + 0.5f * Sin(t * 0.45f)) + 6f * num2;
			for (int i = 0; i < 40; i++)
			{
				for (int j = 0; j < 160; j++)
				{
					int i2 = i * 160 + j;
					float num4 = (float)j + num3 * Sin((float)i * 0.23f + t * 1.3f + (float)j * 0.02f);
					float num5 = (float)i + 0.7f * num3 * Sin((float)j * 0.19f - t * 0.9f);
					if (MaskAt(p, (int)num4, (int)num5) == 0)
					{
						Clear(rgba, i2);
						continue;
					}
					float num6 = Sin((float)j * 0.5f + t * 2f) + Sin((float)i * 0.6f - t * 1.4f);
					float num7 = 0.5f + 0.22f * num6;
					Set(rgba, i2, (byte)Min(255, (int)(60f + 130f * num7)), (byte)Min(255, (int)(20f + 70f * num7)), (byte)Min(255, (int)(90f + 150f * num7)), byte.MaxValue);
				}
			}
		}

		private static void PaintFire(Plate p, byte[] rgba, float t)
		{
			if (p.heat == null)
			{
				p.heat = new byte[6400];
			}
			byte[] heat = p.heat;
			float num = Repeat(t, 9f);
			int num2 = (int)(t * 30f);
			byte b = (byte)((num < 2f) ? (235f * (1f - num / 2f)) : ((num < 2.4f) ? 255f : 230f));
			for (int num3 = 39; num3 >= 1; num3--)
			{
				for (int i = 0; i < 160; i++)
				{
					uint num4 = Hash(i * 3 + 1, num3 * 5 + num2);
					int num5 = i + (int)(num4 % 3) - 1;
					num5 = ((num5 >= 0) ? ((num5 >= 160) ? 159 : num5) : 0);
					int num6 = (int)(heat[(num3 - 1) * 160 + num5] - ((num4 >> 4) & 7) - 5);
					heat[num3 * 160 + i] = (byte)((num6 >= 0) ? ((uint)num6) : 0u);
				}
			}
			for (int j = 0; j < 160; j++)
			{
				int num7 = heat[j] - 24;
				heat[j] = (byte)((num7 >= 0) ? ((uint)num7) : 0u);
			}
			for (int k = 0; k < heat.Length; k++)
			{
				if (p.mask[k] != 0)
				{
					int num8 = (int)(b - Hash(k, num2) % 30);
					if (num8 > heat[k])
					{
						heat[k] = (byte)num8;
					}
				}
			}
			for (int l = 0; l < heat.Length; l++)
			{
				int num9 = heat[l];
				if (num9 < 8)
				{
					Clear(rgba, l);
				}
				else
				{
					Set(rgba, l, (byte)Min(255, num9 * 5 / 2), (byte)((num9 > 96) ? ((uint)Min(255, (num9 - 96) * 5 / 2)) : 0u), (byte)((num9 > 200) ? ((uint)((num9 - 200) * 4)) : 0u), (byte)Min(255, num9 * 3));
				}
			}
		}

		private static void Set(byte[] rgba, int i, byte r, byte g, byte b, byte a)
		{
			int num = i * 4;
			rgba[num] = r;
			rgba[num + 1] = g;
			rgba[num + 2] = b;
			rgba[num + 3] = a;
		}

		private static void Clear(byte[] rgba, int i)
		{
			int num = i * 4;
			rgba[num] = 0;
			rgba[num + 1] = 0;
			rgba[num + 2] = 0;
			rgba[num + 3] = 0;
		}

		private static float Sin(float a)
		{
			return (float)Math.Sin(a);
		}

		private static float Abs(float v)
		{
			if (!(v < 0f))
			{
				return v;
			}
			return 0f - v;
		}

		private static int Min(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		private static int Max(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		private static float Clamp01(float v)
		{
			if (!(v < 0f))
			{
				if (!(v > 1f))
				{
					return v;
				}
				return 1f;
			}
			return 0f;
		}

		private static float Repeat(float a, float m)
		{
			float num = a % m;
			if (!(num < 0f))
			{
				return num;
			}
			return num + m;
		}

		private static uint Hash(int x, int y)
		{
			int num = x * 374761393 + y * 668265263;
			int num2 = (num ^ (num >>> 13)) * 1274126177;
			return (uint)(num2 ^ (num2 >>> 16));
		}

		private static void HsvToRgb(float h, float s, float v, out byte r, out byte g, out byte b)
		{
			h = Repeat(h, 360f) / 60f;
			int num = (int)h;
			float num2 = h - (float)num;
			float num3 = v * (1f - s);
			float num4 = v * (1f - s * num2);
			float num5 = v * (1f - s * (1f - num2));
			float num6;
			float num7;
			float num8;
			switch (num)
			{
			case 0:
				num6 = v;
				num7 = num5;
				num8 = num3;
				break;
			case 1:
				num6 = num4;
				num7 = v;
				num8 = num3;
				break;
			case 2:
				num6 = num3;
				num7 = v;
				num8 = num5;
				break;
			case 3:
				num6 = num3;
				num7 = num4;
				num8 = v;
				break;
			case 4:
				num6 = num5;
				num7 = num3;
				num8 = v;
				break;
			default:
				num6 = v;
				num7 = num3;
				num8 = num4;
				break;
			}
			r = (byte)(num6 * 255f);
			g = (byte)(num7 * 255f);
			b = (byte)(num8 * 255f);
		}
	}
	internal static class StageSyncCoordinator
	{
		private const float ClientWaitTimeout = 30f;

		private const float ClientWaitCeiling = 180f;

		private const float ModHandshakeGrace = 15f;

		private static bool isServer;

		private static bool waitingForClients;

		private static int expectedClients;

		private static int readyClients;

		private static bool hostConvertDone;

		private static float hostConvertDoneTime;

		private static float stageStartTime;

		private static float lastClientHeartbeat;

		private static readonly HashSet<uint> readyUserIds = new HashSet<uint>();

		private static bool localConvertDone;

		private static float localConvertDoneTime;

		private static float nextRosterRefresh;

		private static float nextInRunSync;

		private static float nextProgressPing;

		private static bool hostArcadeLock;

		private static bool metaSendPending;

		private static float nextMetaSendAt;

		private static readonly HashSet<uint> moddedUserIds = new HashSet<uint>();

		private static readonly HashSet<uint> versionWarnedUserIds = new HashSet<uint>();

		private static readonly Dictionary<uint, byte> clientProgress = new Dictionary<uint, byte>();

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

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

		private static readonly Dictionary<uint, CardMeta> userMeta = new Dictionary<uint, CardMeta>();

		private static float prevTimeScale = 1f;

		private static bool froze;

		internal static bool IsServer => isServer;

		internal static int ModdedClientCount => expectedClients;

		private static bool IsRemoteClient
		{
			get
			{
				if (NetworkClient.active)
				{
					return !NetworkServer.active;
				}
				return false;
			}
		}

		internal static bool IsModdedUser(uint userNetId)
		{
			return moddedUserIds.Contains(userNetId);
		}

		public static void OnStageStart()
		{
			stageStartTime = Time.realtimeSinceStartup;
			isServer = NetworkServer.active;
		}

		public static void OnStageReset()
		{
			waitingForClients = false;
			expectedClients = 0;
			readyClients = 0;
			hostConvertDone = false;
			lastClientHeartbeat = 0f;
			readyUserIds.Clear();
			clientProgress.Clear();
			silentConnWarned.Clear();
			localConvertDone = false;
			hostArcadeLock = false;
			metaSendPending = false;
			LoadingRoster.Clear();
		}

		public static void OnRunDestroy()
		{
			userMeta.Clear();
			moddedUserIds.Clear();
			versionWarnedUserIds.Clear();
		}

		public static void FreezeForLoading()
		{
			if (!froze)
			{
				LoadingOverlay.Show();
				prevTimeScale = Time.timeScale;
				Time.timeScale = 0f;
				froze = true;
			}
		}

		public static void Unfreeze()
		{
			LoadingOverlay.Hide();
			if (froze)
			{
				Time.timeScale = prevTimeScale;
				froze = false;
			}
		}

		public static void OnConversionBegin()
		{
			expectedClients = 0;
			if (isServer)
			{
				RecountClients();
				waitingForClients = expectedClients > 0;
				ServerRefreshRoster(broadcast: true);
			}
		}

		public static void OnLocalConversionDone()
		{
			if (!isServer)
			{
				SendClientReady();
				localConvertDone = true;
				localConvertDoneTime = Time.realtimeSinceStartup;
				ConvertProgress.Set("waiting for players", 1);
				ConvertProgress.Done = 1;
				return;
			}
			hostConvertDone = true;
			hostConvertDoneTime = Time.realtimeSinceStartup;
			RecountClients();
			if (!waitingForClients || readyClients >= expectedClients)
			{
				waitingForClients = false;
				if (LootReveal.TryDeferRelease())
				{
					ConvertProgress.Set("revealing unlocks", 1);
					ConvertProgress.Done = 1;
					ServerRefreshRoster(expectedClients > 0);
				}
				else if (ArcadeHost.HoldingLoadingScreen)
				{
					ConvertProgress.Set("held by the host — arcade time", 1);
					ConvertProgress.Done = 1;
					ServerRefreshRoster(expectedClients > 0);
				}
				else
				{
					ServerRefreshRoster(expectedClients > 0, forceAllReady: true);
					Unfreeze();
				}
			}
			else
			{
				ConvertProgress.Set("waiting for players", expectedClients);
				ConvertProgress.Done = readyClients;
				ServerRefreshRoster(broadcast: true);
				if (ModOptions.VerboseLogging.Value)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] host ready; waiting for {expectedClients - readyClients} of {expectedClients} client(s) to finish converting");
				}
			}
		}

		public static void Tick()
		{
			//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)
			if (isServer && waitingForClients)
			{
				RecountClients();
			}
			if (isServer && froze && Time.realtimeSinceStartup >= nextRosterRefresh)
			{
				nextRosterRefresh = Time.realtimeSinceStartup + 1f;
				ServerRefreshRoster(expectedClients > 0);
				if (expectedClients > 0)
				{
					VoxelTerrainManager.SendStageConfig();
					LootReveal.ServerResendReels();
				}
			}
			if (isServer && !froze && (Object)(object)Run.instance != (Object)null && Time.realtimeSinceStartup >= nextInRunSync)
			{
				nextInRunSync = Time.realtimeSinceStartup + 10f;
				ServerRefreshRoster(expectedClients > 0);
			}
			if (!isServer && froze && !localConvertDone && NetworkClient.active && Time.realtimeSinceStartup >= nextProgressPing)
			{
				nextProgressPing = Time.realtimeSinceStartup + 2f;
				byte percent = (byte)Mathf.Clamp(ConvertProgress.Fraction() * 100f, 0f, 100f);
				List<uint> list = new List<uint>();
				foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
				{
					if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
					{
						NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
						list.Add(((NetworkInstanceId)(ref netId)).Value);
					}
				}
				if (list.Count > 0)
				{
					NetMessageExtensions.Send((INetMessage)(object)new ConvertProgressMessage(list.ToArray(), percent), (NetworkDestination)2);
				}
			}
			if (!isServer && localConvertDone && froze)
			{
				string text = (hostArcadeLock ? "held by the host — arcade time" : "waiting for players");
				if (ConvertProgress.Phase != text)
				{
					ConvertProgress.Set(text, 1);
					ConvertProgress.Done = 1;
				}
			}
			if (metaSendPending && IsRemoteClient && Time.realtimeSinceStartup >= nextMetaSendAt)
			{
				metaSendPending = false;
				nextMetaSendAt = Time.realtimeSinceStartup + 1f;
				SendLifetimeBase();
			}
			if (!isServer && localConvertDone && froze && !ArcadeHost.HoldingLoadingScreen && ((LoadingRoster.AllReady && !LootReveal.HoldingRelease) || Time.realtimeSinceStartup - Mathf.Max(localConvertDoneTime, LoadingRoster.LastSyncTime) > 35f))
			{
				localConvertDone = false;
				Unfreeze();
			}
			if (isServer && LootReveal.RevealRunning && !LootReveal.HoldingRelease && !ArcadeHost.HoldingLoadingScreen)
			{
				LootReveal.FinishReveal();
				ServerRefreshRoster(broadcast: true, forceAllReady: true);
				Unfreeze();
			}
			if (isServer && froze && hostConvertDone && !waitingForClients && !LootReveal.RevealRunning && VoxelTerrainManager.LocalConversionDone && !ArcadeHost.HoldingLoadingScreen)
			{
				ServerRefreshRoster(expectedClients > 0, forceAllReady: true);
				Unfreeze();
			}
			if (!waitingForClients || !hostConvertDone || ArcadeHost.HoldingLoadingScreen)
			{
				return;
			}
			ConvertProgress.Total = expectedClients;
			ConvertProgress.Done = readyClients;
			bool flag = readyClients >= expectedClients;
			float num = Mathf.Max(hostConvertDoneTime, lastClientHeartbeat);
			bool flag2 = Time.realtimeSinceStartup - num > 30f;
			bool flag3 = Time.realtimeSinceStartup - hostConvertDoneTime > 180f;
			if (!(flag || flag2 || flag3))
			{
				return;
			}
			waitingForClients = false;
			if (LootReveal.TryDeferRelease())
			{
				ConvertProgress.Set("revealing unlocks", 1);
				ConvertProgress.Done = 1;
				ServerRefreshRoster(broadcast: true);
			}
			else
			{
				ServerRefreshRoster(broadcast: true, forceAllReady: true);
				Unfreeze();
			}
			if (flag)
			{
				if (ModOptions.VerboseLogging.Value)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] all {expectedClients} client(s) ready — starting stage");
				}
			}
			else
			{
				float num2 = (flag2 ? 30f : 180f);
				ScorchedVoxelsPlugin.Log.LogWarning((object)($"[ScorchedVoxels] loading client(s) not ready after {num2:F0}s " + $"({readyClients}/{expectedClients} ready) — starting without them"));
			}
		}

		public static void StoreHostLock(bool locked)
		{
			hostArcadeLock = locked;
		}

		public static void OnLocalCardMetaChanged()
		{
			if (IsRemoteClient)
			{
				metaSendPending = true;
			}
		}

		public static void StoreLifetimeBase(uint userNetId, in CardMeta meta)
		{
			if (userNetId != 0 && meta.m3Base >= 0.0)
			{
				moddedUserIds.Add(userNetId);
				userMeta[userNetId] = meta;
			}
		}

		public static void StoreClientProgress(uint[] userIds, byte percent)
		{
			if (!NetworkServer.active || userIds == null)
			{
				return;
			}
			foreach (uint num in userIds)
			{
				if (num != 0)
				{
					moddedUserIds.Add(num);
					clientProgress.TryGetValue(num, out var value);
					if (percent > value)
					{
						lastClientHeartbeat = Time.realtimeSinceStartup;
					}
					clientProgress[num] = percent;
				}
			}
		}

		public static void NotifyClientConverted(uint[] userIds, string clientVersion)
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			lastClientHeartbeat = Time.realtimeSinceStartup;
			if (userIds != null)
			{
				foreach (uint item in userIds)
				{
					readyUserIds.Add(item);
					moddedUserIds.Add(item);
				}
			}
			RecountClients();
			if (clientVersion != "0.20.72")
			{
				uint item2 = ((userIds != null && userIds.Length != 0) ? userIds[0] : 0u);
				if (versionWarnedUserIds.Add(item2))
				{
					string text = "a player";
					if (userIds != null && userIds.Length != 0)
					{
						foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
						{
							if ((Object)(object)readOnlyInstances != (Object)null)
							{
								NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
								if (((NetworkInstanceId)(ref netId)).Value == userIds[0])
								{
									text = readOnlyInstances.userName;
									break;
								}
							}
						}
					}
					string text2 = "<color=#ff7755>[ScorchedVoxels] " + text + " runs version " + clientVersion + " (host: 0.20.72) — their terrain stays vanilla. Everyone should update to the same version.</color>";
					ScorchedVoxelsPlugin.Log.LogError((object)text2);
					SimpleChatMessage val = new SimpleChatMessage();
					val.baseToken = "{0}";
					val.paramTokens = new string[1] { text2 };
					Chat.SendBroadcastChat((ChatMessageBase)(object)val);
				}
			}
			ServerRefreshRoster(broadcast: true);
		}

		public static void SendClientReady()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			List<uint> list = new List<uint>();
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					list.Add(((NetworkInstanceId)(ref netId)).Value);
				}
			}
			NetMessageExtensions.Send((INetMessage)(object)new ClientConvertedMessage(list.ToArray(), "0.20.72"), (NetworkDestination)2);
			SendLifetimeBase();
		}

		public static void SendLifetimeBase()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			List<uint> list = new List<uint>();
			List<CardMeta> list2 = new List<CardMeta>();
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					list.Add(((NetworkInstanceId)(ref netId)).Value);
					list2.Add(CollectCardMeta(readOnlyInstances));
				}
			}
			if (list.Count > 0)
			{
				NetMessageExtensions.Send((INetMessage)(object)new LifetimeBaseMessage(list.ToArray(), list2.ToArray()), (NetworkDestination)2);
			}
		}

		private static CardMeta CollectCardMeta(NetworkUser nu)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			string profileKey = UserLifetimeStats.ProfileKey(nu);
			CardMeta cardMeta = new CardMeta
			{
				m3Base = UserLifetimeStats.GetRunBase(nu),
				title = TitleSystem.CurrentTitle(nu)
			};
			NetworkInstanceId netId = ((NetworkBehaviour)nu).netId;
			cardMeta.titleNew = TitleSystem.IsFresh(((NetworkInstanceId)(ref netId)).Value);
			cardMeta.bg = BackgroundSystem.CurrentBackground(nu);
			cardMeta.runnerBest = UserLifetimeStats.RunnerBest(profileKey);
			cardMeta.wormsDug = UserLifetimeStats.WormsDug(profileKey);
			cardMeta.prefA = -1;
			cardMeta.prefB = -1;
			cardMeta.prefC = -1;
			CardMeta result = cardMeta;
			IReadOnlyList<int> readOnlyList = UserLifetimeStats.ArcadeColors(profileKey);
			if (readOnlyList.Count > 0)
			{
				result.prefA = readOnlyList[0];
			}
			if (readOnlyList.Count > 1)
			{
				result.prefB = readOnlyList[1];
			}
			if (readOnlyList.Count > 2)
			{
				result.prefC = readOnlyList[2];
			}
			result.nameFx = UserLifetimeStats.EffectiveNameFx(profileKey);
			return result;
		}

		private static byte[] QuantizeClasses(float[] classes)
		{
			byte[] array = new byte[8];
			float num = 0f;
			for (int i = 0; i < classes.Length && i < 8; i++)
			{
				num += classes[i];
			}
			if (num <= 0f)
			{
				return array;
			}
			for (int j = 0; j < classes.Length && j < 8; j++)
			{
				array[j] = (byte)Mathf.Clamp(classes[j] / num * 255f, 0f, 255f);
			}
			return array;
		}

		private static void RecountClients()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			connFlags.Clear();
			bool flag = Time.realtimeSinceStartup - stageStartTime < 15f;
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances == (Object)null || ((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					continue;
				}
				NetworkConnection connectionToClient = ((NetworkBehaviour)readOnlyInstances).connectionToClient;
				if (connectionToClient != null)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					uint value = ((NetworkInstanceId)(ref netId)).Value;
					connFlags.TryGetValue(connectionToClient.connectionId, out var value2);
					if (moddedUserIds.Contains(value))
					{
						value2 |= 1;
					}
					if (readyUserIds.Contains(value))
					{
						value2 |= 3;
					}
					connFlags[connectionToClient.connectionId] = value2;
				}
			}
			expectedClients = 0;
			readyClients = 0;
			foreach (KeyValuePair<int, int> connFlag in connFlags)
			{
				if ((connFlag.Value & 1) == 0 && !flag)
				{
					if (silentConnWarned.Add(connFlag.Key))
					{
						ScorchedVoxelsPlugin.Log.LogWarning((object)$"[ScorchedVoxels] no mod traffic from connection {connFlag.Key} after {15f:F0}s — not holding the stage for them (ScorchedVoxels missing on that machine?)");
					}
					continue;
				}
				expectedClients++;
				if ((connFlag.Value & 2) != 0)
				{
					readyClients++;
				}
			}
		}

		private static void ServerRefreshRoster(bool broadcast, bool forceAllReady = false)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				return;
			}
			bool flag = !LootReveal.HoldingRelease && !ArcadeHost.HoldingLoadingScreen && (forceAllReady || (hostConvertDone && readyClients >= expectedClients));
			LoadingRoster.Entries.Clear();
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if (!((Object)(object)readOnlyInstances == (Object)null))
				{
					StatSheet val = (((Object)(object)readOnlyInstances.master != (Object)null && (Object)(object)readOnlyInstances.master.playerStatsComponent != (Object)null) ? readOnlyInstances.master.playerStatsComponent.currentStats : null);
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					uint value = ((NetworkInstanceId)(ref netId)).Value;
					CardMeta value2;
					if (((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
					{
						value2 = CollectCardMeta(readOnlyInstances);
					}
					else if (!userMeta.TryGetValue(value, out value2))
					{
						value2 = new CardMeta
						{
							title = -1,
							prefA = -1,
							prefB = -1,
							prefC = -1,
							nameFx = -1
						};
					}
					bool flag2 = flag || (((NetworkBehaviour)readOnlyInstances).isLocalPlayer ? hostConvertDone : readyUserIds.Contains(value));
					byte value3;
					if (flag2)
					{
						value3 = 100;
					}
					else if (((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
					{
						value3 = (byte)Mathf.Clamp(ConvertProgress.Fraction() * 100f, 0f, 100f);
					}
					else
					{
						clientProgress.TryGetValue(value, out value3);
					}
					LoadingRoster.Entries.Add(new RosterEntry
					{
						userNetId = value,
						ready = flag2,
						progress = value3,
						kills = (uint)((val != null) ? val.GetStatValueULong(StatDef.totalKills) : 0u),
						damage = ((val != null) ? val.GetStatValueULong(StatDef.totalDamageDealt) : 0),
						gold = ((val != null) ? val.GetStatValueULong(StatDef.goldCollected) : 0),
						m3Stage = CarveStats.GetLastStage(value),
						m3Run = CarveStats.GetRun(value),
						m3Ever = value2.m3Base + (double)CarveStats.GetRun(value),
						matShare = QuantizeClasses(CarveStats.GetRunClasses(value)),
						title = value2.title,
						titleNew = value2.titleNew,
						bg = value2.bg,
						runnerBest = value2.runnerBest,
						wormsDug = value2.wormsDug,
						prefA = value2.prefA,
						prefB = value2.prefB,
						prefC = value2.prefC,
						nameFx = value2.nameFx
					});
				}
			}
			LoadingRoster.AllReady = flag;
			if (broadcast)
			{
				NetMessageExtensions.Send((INetMessage)(object)new LoadingSyncMessage(LoadingRoster.Entries, flag, ArcadeHost.HoldingLoadingScreen), (NetworkDestination)1);
			}
			UserLifetimeStats.Bank();
		}
	}
	internal static class TitlePickerUI
	{
		private enum Mode
		{
			Titles,
			Backgrounds,
			ArcadeColors,
			Names
		}

		private class Tile
		{
			public int idx;

			public UiTile ui;

			public RawImage preview;

			public UiKit.Label label;

			public bool unlocked;
		}

		private abstract class Page
		{
			public abstract string Header { get; }

			public abstract float BuildGrid(RectTransform content, float contentW);

			public abstract void Refresh();

			public virtual void Tick()
			{
			}
		}

		private abstract class TilePage : Page
		{
			protected readonly List<Tile> tiles = new List<Tile>();

			private readonly List<(int idx, Vector2 pos)> pendingTiles = new List<(int, Vector2)>();

			protected RectTransform contentRect;

			private Vector2 tileSize;

			private const int TilesPerTick = 12;

			protected abstract int TableLength { get; }

			protected abstract float TileH { get; }

			protected abstract int Chosen { get; set; }

			protected abstract float TileW(float contentW);

			protected abstract int Columns(float contentW, float tileW);

			protected virtual string SectionAt(int idx)
			{
				return null;
			}

			protected virtual int DisplayIndex(int slot)
			{
				return slot;
			}

			protected abstract void BuildFurniture(Tile tile);

			protected abstract int RefreshMeta();

			public override float BuildGrid(RectTransform content, float contentW)
			{
				//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)
				tiles.Clear();
				pendingTiles.Clear();
				contentRect = content;
				float tileW = TileW(contentW);
				float tileH = TileH;
				tileSize = new Vector2(tileW, tileH);
				int cols = Columns(contentW, tileW);
				float gridW = (float)cols * tileW + (float)(cols - 1) * 8f;
				float left = (0f - gridW) * 0.5f;
				float y = 0f;
				int col = 0;
				for (int i = 0; i < TableLength; i++)
				{
					int idx = DisplayIndex(i);
					string text = SectionAt(idx);
					if (text != null)
					{
						SectionHeader(text);
					}
					PlaceTile(idx);
				}
				NewRowIfNeeded();
				BuildPendingBatch();
				return 0f - y + 8f;
				void NewRowIfNeeded()
				{
					if (col > 0)
					{
						y -= tileH + 8f;
						col = 0;
					}
				}
				void PlaceTile(int item)
				{
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					float num = left + (float)col * (tileW + 8f) + tileW * 0.5f;
					float num2 = y - tileH * 0.5f;
					pendingTiles.Add((item, new Vector2(num, num2)));
					if (++col >= cols)
					{
						y -= tileH + 8f;
						col = 0;
					}
				}
				void SectionHeader(string text2)
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0067: Unknown result type (might be due to invalid IL or missing references)
					//IL_0088: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
					//IL_0100: Unknown result type (might be due to invalid IL or missing references)
					//IL_011b: 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)
					NewRowIfNeeded();
					UiKit.Label label = UiKit.CreateLabel("section", (Transform)(object)content, 14f, UiKit.HeaderTan, (TextAnchor)6);
					label.Rect.anchorMin = new Vector2(0.5f, 1f);
					label.Rect.anchorMax = new Vector2(0.5f, 1f);
					label.Rect.sizeDelta = new Vector2(gridW, 22f);
					label.Rect.anchoredPosition = new Vector2(0f, y - 15f);
					label.Bold();
					label.Text = text2;
					Image obj = UiKit.CreateImage("rule", (Transform)(object)content, new Color(UiKit.HeaderTan.r, UiKit.HeaderTan.g, UiKit.HeaderTan.b, 0.25f));
					((Graphic)obj).rectTransform.anchorMin = new Vector2(0.5f, 1f);
					((Graphic)obj).rectTransform.anchorMax = new Vector2(0.5f, 1f);
					((Graphic)obj).rectTransform.sizeDelta = new Vector2(gridW, 1.5f);
					((Graphic)obj).rectTransform.anchoredPosition = new Vector2(0f, y - 30f + 2f);
					y -= 35f;
				}
			}

			private bool BuildPendingBatch()
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				if (pendingTiles.Count == 0 || (Object)(object)contentRect == (Object)null)
				{
					return false;
				}
				int num = Mathf.Min(12, pendingTiles.Count);
				for (int i = 0; i < num; i++)
				{
					(int, Vector2) tuple = pendingTiles[i];
					int idx = tuple.Item1;
					Vector2 item = tuple.Item2;
					Tile tile = new Tile
					{
						idx = idx
					};
					tile.ui = new UiTile($"tile_{idx}", contentRect, tileSize, item, (UnityAction)delegate
					{
						OnTileClicked(idx);
					});
					BuildFurniture(tile);
					tiles.Add(tile);
				}
				pendingTiles.RemoveRange(0, num);
				return true;
			}

			public override void Tick()
			{
				if (BuildPendingBatch())
				{
					Refresh();
				}
			}

			public override void Refresh()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				int num = RefreshMeta();
				foreach (Tile tile in tiles)
				{
					tile.ui.Selected = tile.idx == num;
					float num2 = (tile.unlocked ? 1f : 0.45f);
					Color panelMid = UiKit.PanelMid;
					((Graphic)tile.ui.Face).color = new Color(panelMid.r, panelMid.g, panelMid.b, num2);
					if ((Object)(object)tile.preview != (Object)null)
					{
						float num3 = (tile.unlocked ? 1f : 0.4f);
						((Graphic)tile.preview).color = new Color(num3, num3, num3, tile.unlocked ? 1f : 0.55f);
					}
					if (tile.label != null)
					{
						tile.label.Color = new Color(UiKit.TextPale.r, UiKit.TextPale.g, UiKit.TextPale.b, tile.unlocked ? 1f : 0.45f);
					}
				}
			}

			private void OnTileClicked(int idx)
			{
				Tile tile = null;
				foreach (Tile tile2 in tiles)
				{
					if (tile2.idx == idx)
					{
						tile = tile2;
						break;
					}
				}
				if (tile != null && tile.unlocked)
				{
					int chosen = Chosen;
					Chosen = ((chosen == idx) ? (-1) : idx);
					Refresh();
				}
			}
		}

		private sealed class TitlesPage : TilePage
		{
			private const float RowH = 32f;

			public override string Header => "TITLES";

			protected override int TableLength => TitleSystem.Table.Length;

			protected override float TileH => 32f;

			protected override int Chosen
			{
				get
				{
					return UserLifetimeStats.GetChosenTitle(profileKey);
				}
				set
				{
					UserLifetimeStats.SetChosenTitle(profileKey, value);
				}
			}

			protected override float TileW(float contentW)
			{
				return Mathf.Min(contentW, 640f);
			}

			protected override int Columns(float contentW, float tileW)
			{
				return 1;
			}

			protected override void BuildFurniture(Tile tile)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				tile.label = UiKit.CreateLabel($"label_{tile.idx}", ((Component)tile.ui.Face).transform, 13f, UiKit.TextPale, (TextAnchor)3);
				UiKit.Stretch(tile.label.Rect);
				tile.label.Rect.offsetMin = new Vector2(10f, 2f);
				tile.label.Rect.offsetMax = new Vector2(-10f, -2f);
				tile.label.ClipSingleLine();
				tile.label.Text = TitleSystem.Table[tile.idx];
			}

			protected override int RefreshMeta()
			{
				IReadOnlyList<int> readOnlyList = UserLifetimeStats.UnlockedTitles(profileKey);
				HashSet<int> hashSet = new HashSet<int>(readOnlyList);
				int result = UserLifetimeStats.EffectiveTitle(profileKey);
				foreach (Tile tile in tiles)
				{
					tile.unlocked = hashSet.Contains(tile.idx);
				}
				if (headerCount != null)
				{
					headerCount.Text = $"{readOnlyList.Count} / {TitleSystem.Table.Length}";
				}
				if (footer != null)
				{
					footer.Text = $"Click an earned title to wear it; click it again for auto. Every cleared level rolls a {ModOptions.TitleChance.Value:P0} chance at a new one.";
				}
				return result;
			}
		}

		private sealed class BackgroundsPage : TilePage
		{
			private const float BgTileW = 88f;

			private const float BgTileH = 132f;

			private int current = -1;

			private int[] order;

			public override string Header => "CARD BACKGROUNDS";

			protected override int TableLength => BackgroundSystem.Table.Length;

			protected override float TileH => 132f;

			protected override int Chosen
			{
				get
				{
					return UserLifetimeStats.GetChosenBackground(profileKey);
				}
				set
				{
					UserLifetimeStats.SetChosenBackground(profileKey, value);
				}
			}

			protected override float TileW(float contentW)
			{
				return 88f;
			}

			protected override int Columns(float contentW, float tileW)
			{
				return Mathf.Max(2, Mathf.FloorToInt((contentW + 8f) / (tileW + 8f)));
			}

			private static int Band(int idx)
			{
				BackgroundSystem.Def def = BackgroundSystem.Table[idx];
				if (def.cat == BgCat.Pride)
				{
					return 2;
				}
				if (def.cat == BgCat.Flag)
				{
					return 3;
				}
				if (def.anim == null && def.live == LiveSkin.None)
				{
					return 0;
				}
				return 1;
			}

			protected override int DisplayIndex(int slot)
			{
				if (order == null)
				{
					order = new int[BackgroundSystem.Table.Length];
					for (int i = 0; i < order.Length; i++)
					{
						order[i] = i;
					}
					Array.Sort(order, delegate(int a, int b)
					{
						int num = Band(a).CompareTo(Band(b));
						return (num == 0) ? a.CompareTo(b) : num;
					});
				}
				return order[slot];
			}

			protected override string SectionAt(int idx)
			{
				int num = Band(idx);
				if (num == current)
				{
					return null;
				}
				current = num;
				return num switch
				{
					1 => "ANIMATED  ·  level lottery", 
					2 => "PRIDE  ·  always free", 
					3 => "FLAGS  ·  every country, always free", 
					_ => "PATTERNS  ·  level lottery", 
				};
			}

			public override void Tick()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				base.Tick();
				if ((Object)(object)contentRect != (Object)null)
				{
					float y = contentRect.anchoredPosition.y;
					Transform parent = ((Transform)contentRect).parent;
					RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
					float num;
					if (!((Object)(object)val != (Object)null))
					{
						num = 900f;
					}
					else
					{
						Rect rect = val.rect;
						num = ((Rect)(ref rect)).height;
					}
					float num2 = num;
					foreach (Tile tile3 in tiles)
					{
						if (!((Object)(object)tile3.preview == (Object)null) && BackgroundSystem.Table[tile3.idx].anim != null)
						{
							float num3 = 0f - ((Graphic)tile3.ui.Face).rectTransform.anchoredPosition.y;
							if (num3 > y - 132f && num3 < y + num2 + 132f)
							{
								BackgroundSystem.MarkAnimatedVisible(tile3.idx);
							}
						}
					}
				}
				BackgroundSystem.TickAnimated(Time.unscaledTime);
				foreach (Tile tile4 in tiles)
				{
					if ((Object)(object)tile4.preview == (Object)null)
					{
						continue;
					}
					BackgroundSystem.Def def = BackgroundSystem.Table[tile4.idx];
					if (def.live != LiveSkin.None)
					{
						Texture val2 = TerrariumSkins.TryGetCardSkin((int)def.live);
						if ((Object)(object)val2 == (Object)null)
						{
							val2 = (Texture)(object)BackgroundSystem.GetTexture(tile4.idx);
						}
						if ((Object)(object)tile4.preview.texture != (Object)(object)val2)
						{
							tile4.preview.texture = val2;
						}
					}
				}
			}

			protected override void BuildFurniture(Tile tile)
			{
				//IL_005f: 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_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: 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_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: 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)
				tile.preview = UiKit.CreateMaskedCard("preview", tile.ui.Face, (Texture)(object)BackgroundSystem.GetTexture(tile.idx));
				Image val = UiKit.CreateImage($"strip_{tile.idx}", ((Component)tile.ui.Face).transform, new Color(0f, 0f, 0f, 0.62f));
				((Graphic)val).rectTransform.anchorMin = new Vector2(0f, 0f);
				((Graphic)val).rectTransform.anchorMax = new Vector2(1f, 0f);
				((Graphic)val).rectTransform.pivot = new Vector2(0.5f, 0f);
				((Graphic)val).rectTransform.sizeDelta = new Vector2(0f, 22f);
				((Graphic)val).rectTransform.anchoredPosition = Vector2.zero;
				((Graphic)val).raycastTarget = false;
				tile.label = UiKit.CreateLabel($"label_{tile.idx}", ((Component)val).transform, 10f, UiKit.TextPale, (TextAnchor)4);
				UiKit.Stretch(tile.label.Rect);
				tile.label.Rect.offsetMin = new Vector2(3f, 0f);
				tile.label.Rect.offsetMax = new Vector2(-3f, 0f);
				tile.label.ClipSingleLine();
				tile.label.Text = BackgroundSystem.Table[tile.idx].name;
			}

			protected override int RefreshMeta()
			{
				int result = BackgroundSystem.CurrentForProfile(profileKey);
				foreach (Tile tile in tiles)
				{
					tile.unlocked = BackgroundSystem.IsOwned(profileKey, tile.idx);
				}
				if (headerCount != null)
				{
					headerCount.Text = $"patterns {UserLifetimeStats.UnlockedBackgrounds(profileKey).Count} / {BackgroundSystem.PatternCount()}";
				}
				if (footer != null)
				{
					footer.Text = "Click to wear, click again for auto. Patterns drop from the level lottery; flags and pride are always yours.";
				}
				return result;
			}
		}

		private sealed class NamesPage : TilePage
		{
			private const float RowH = 34f;

			private NameFxSystem.Tier? current;

			private int[] order;

			private readonly Dictionary<int, UiKit.Label> lockTags = new Dictionary<int, UiKit.Label>();

			public override string Header => "NAME EFFECTS";

			protected override int TableLength => NameFxSystem.Table.Length;

			protected override float TileH => 34f;

			protected override int Chosen
			{
				get
				{
					return UserLifetimeStats.GetChosenNameFx(profileKey);
				}
				set
				{
					UserLifetimeStats.SetChosenNameFx(profileKey, value);
				}
			}

			protected override int DisplayIndex(int slot)
			{
				if (order == null)
				{
					order = new int[NameFxSystem.Table.Length];
					for (int i = 0; i < order.Length; i++)
					{
						order[i] = i;
					}
					Array.Sort(order, delegate(int a, int b)
					{
						int num = NameFxSystem.Table[a].tier.CompareTo(NameFxSystem.Table[b].tier);
						return (num == 0) ? a.CompareTo(b) : num;
					});
				}
				return order[slot];
			}

			protected override float TileW(float contentW)
			{
				return Mathf.Min(contentW, 640f);
			}

			protected override int Columns(float contentW, float tileW)
			{
				return 1;
			}

			protected override string SectionAt(int idx)
			{
				NameFxSystem.Tier tier = NameFxSystem.Table[idx].tier;
				if (current == tier)
				{
					return null;
				}
				current = tier;
				return tier switch
				{
					NameFxSystem.Tier.White => "WHITE  ·  any evolution", 
					NameFxSystem.Tier.Green => "GREEN  ·  later evolutions", 
					NameFxSystem.Tier.Red => "RED  ·  the final molt, and prestige", 
					_ => "LUNAR  ·  the pet's finale, and prestige", 
				};
			}

			protected override void BuildFurniture(Tile tile)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: 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)
				tile.label = UiKit.CreateLabel($"label_{tile.idx}", ((Component)tile.ui.Face).transform, 13f, UiKit.TextPale, (TextAnchor)3);
				UiKit.Stretch(tile.label.Rect);
				tile.label.Rect.offsetMin = new Vector2(10f, 2f);
				tile.label.Rect.offsetMax = new Vector2(-100f, -2f);
				tile.label.ClipSingleLine();
				tile.label.Text = NameFxSystem.Table[tile.idx].name;
				UiKit.Label label = UiKit.CreateLabel($"lock_{tile.idx}", ((Component)tile.ui.Face).transform, 9f, UiKit.TextDim, (TextAnchor)5);
				UiKit.Stretch(label.Rect);
				label.Rect.offsetMin = new Vector2(10f, 2f);
				label.Rect.offsetMax = new Vector2(-10f, -2f);
				label.ClipSingleLine();
				label.Text = "LOCKED";
				lockTags[tile.idx] = label;
			}

			protected override int RefreshMeta()
			{
				IReadOnlyList<int> readOnlyList = UserLifetimeStats.UnlockedNameFx(profileKey);
				HashSet<int> hashSet = new HashSet<int>(readOnlyList);
				int result = UserLifetimeStats.EffectiveNameFx(profileKey);
				foreach (Tile tile in tiles)
				{
					tile.unlocked = hashSet.Contains(tile.idx);
					if (lockTags.TryGetValue(tile.idx, out var value))
					{
						value.Text = (tile.unlocked ? "" : "LOCKED");
					}
				}
				if (headerCount != null)
				{
					headerCount.Text = $"{readOnlyList.Count} / {NameFxSystem.Table.Length}";
				}
				if (footer != null)
				{
					footer.Text = "Click an earned effect to wear it on your name; click again for auto. The terrarium pet digs these up as it grows.";
				}
				return result;
			}

			public override void Tick()
			{
				base.Tick();
				float unscaledTime = Time.unscaledTime;
				foreach (Tile tile in tiles)
				{
					if (tile.label != null)
					{
						NameFxSystem.Animate(tile.label, tile.idx, 4027408109u, unscaledTime, tile.unlocked ? 1f : 0.62f);
					}
				}
			}
		}

		private sealed class ArcadeColorsPage : Page
		{
			private ArcadeColorGrid grid;

			public override string Header => "ARCADE COLORS";

			public override float BuildGrid(RectTransform content, float contentW)
			{
				grid = new ArcadeColorGrid
				{
					onChanged = Refresh
				};
				return grid.Build(content, contentW, profileKey);
			}

			public override void Refresh()
			{
				grid?.Refresh();
				if (headerCount != null)
				{
					headerCount.Text = $"{grid?.PickedCount ?? 0} / 3 picked";
				}
				if (footer != null)
				{
					footer.Text = "Click up to three commandos in order of preference — the first is your favorite. Click a pick to drop it. The arcade gives everyone their highest free choice.";
				}
			}

			public override void Tick()
			{
				grid?.Tick();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Close;
		}

		private static Mode mode;

		private const float Pad = 12f;

		private const float HeaderH = 46f;

		private const float FooterH = 48f;

		private const float SectionH = 30f;

		private const float Gap = 8f;

		private static GameObject root;

		private static string profileKey;

		private static Page page;

		private static UiKit.Label footer;

		private static UiKit.Label headerCount;

		public static void Toggle()
		{
			if ((Object)(object)root != (Object)null && mode == Mode.Titles)
			{
				Close();
			}
			else
			{
				Open(Mode.Titles);
			}
		}

		public static void ToggleBackgrounds()
		{
			if ((Object)(object)root != (Object)null && mode == Mode.Backgrounds)
			{
				Close();
			}
			else
			{
				Open(Mode.Backgrounds);
			}
		}

		public static void ToggleArcadeColors()
		{
			if ((Object)(object)root != (Object)null && mode == Mode.ArcadeColors)
			{
				Close();
				return;
			}
			CommandoSprites.EnsureLoading();
			Open(Mode.ArcadeColors);
		}

		public static void ToggleNames()
		{
			if ((Object)(object)root != (Object)null && mode == Mode.Names)
			{
				Close();
			}
			else
			{
				Open(Mode.Names);
			}
		}

		public static void Tick()
		{
			if ((Object)(object)root != (Object)null)
			{
				page?.Tick();
			}
		}

		public static void Close()
		{
			if ((Object)(object)root != (Object)null)
			{
				Object.Destroy((Object)(object)root);
			}
			root = null;
			page = null;
			footer = null;
			headerCount = null;
		}

		private static void Open(Mode m)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_011f: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01a0: Expected O, but got Unknown
			Close();
			mode = m;
			profileKey = UserLifetimeStats.ProfileKey(LocalUserManager.GetFirstLocalUser());
			if (profileKey == null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] picker: no user profile to pick for");
				return;
			}
			page = m switch
			{
				Mode.Names => new NamesPage(), 
				Mode.Backgrounds => new BackgroundsPage(), 
				Mode.Titles => new TitlesPage(), 
				_ => new ArcadeColorsPage(), 
			};
			GameObject val = (((Object)(object)EventSystem.current != (Object)null) ? EventSystem.current.currentSelectedGameObject : null);
			RectTransform val2 = FindSettingsSubPanel(val);
			RectTransform val3 = FindDescriptionPanel(val2) ?? val2;
			if ((Object)(object)val3 != (Object)null)
			{
				root = new GameObject("ScorchedVoxelsPicker");
				root.transform.SetParent((Transform)(object)val3, false);
				RectTransform obj = root.AddComponent<RectTransform>();
				UiKit.Stretch(obj);
				BuildInto(obj, val, val2);
				return;
			}
			ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] picker: settings panel not found, using overlay");
			root = new GameObject("ScorchedVoxelsPickerOverlay");
			Canvas obj2 = root.AddComponent<Canvas>();
			obj2.renderMode = (RenderMode)0;
			obj2.sortingOrder = 30500;
			CanvasScaler obj3 = root.AddComponent<CanvasScaler>();
			obj3.uiScaleMode = (ScaleMode)1;
			obj3.referenceResolution = new Vector2(1920f, 1080f);
			obj3.matchWidthOrHeight = 1f;
			root.AddComponent<GraphicRaycaster>();
			Image obj4 = UiKit.CreateImage("backdrop", root.transform, new Color(0f, 0f, 0f, 0.72f));
			UiKit.Stretch(((Graphic)obj4).rectTransform);
			ButtonClickedEvent onClick = ((Component)obj4).gameObject.AddComponent<Button>().onClick;
			object obj5 = <>O.<0>__Close;
			if (obj5 == null)
			{
				UnityAction val4 = Close;
				<>O.<0>__Close = val4;
				obj5 = (object)val4;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj5);
			GameObject val5 = new GameObject("panel");
			val5.transform.SetParent(root.transform, false);
			RectTransform obj6 = val5.AddComponent<RectTransform>();
			obj6.sizeDelta = new Vector2(560f, 820f);
			BuildInto(obj6, null, null);
		}

		private static RectTransform FindSettingsSubPanel(GameObject from)
		{
			Transform val = (((Object)(object)from != (Object)null) ? from.transform : null);
			while ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name.StartsWith("SettingsSubPanel"))
				{
					RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
					if (val2 != null)
					{
						return val2;
					}
				}
				val = val.parent;
			}
			GameObject val3 = GameObject.Find("SettingsSubPanel, (Mod Options)");
			if (!((Object)(object)val3 != (Object)null))
			{
				return null;
			}
			return val3.GetComponent<RectTransform>();
		}

		private static RectTransform FindDescriptionPanel(RectTransform subPanel)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if ((Object)(object)subPanel == (Object)null)
			{
				return null;
			}
			foreach (Transform item in (Transform)subPanel)
			{
				Transform val = item;
				if (((Component)val).gameObject.activeSelf && ((Object)val).name.StartsWith("Option Description Panel"))
				{
					RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
					if (val2 != null)
					{
						return val2;
					}
				}
			}
			return null;
		}

		private static void BuildInto(RectTransform container, GameObject styleDonorButton, RectTransform subPanel)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: 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_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: 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_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			UiKit.Stretch(new UiWindow("chrome", (Transform)(object)container, UiKit.PanelSolid, UiKit.Outline).Rect);
			Rect rect = container.rect;
			float num = ((Rect)(ref rect)).width;
			if (num < 200f)
			{
				num = 460f;
			}
			UiKit.Label label = UiKit.CreateLabel("header", (Transform)(object)container, 19f, UiKit.HeaderTan, (TextAnchor)3);
			label.Rect.anchorMin = new Vector2(0f, 1f);
			label.Rect.anchorMax = new Vector2(1f, 1f);
			label.Rect.pivot = new Vector2(0.5f, 1f);
			label.Rect.sizeDelta = new Vector2(-24f, 30f);
			label.Rect.anchoredPosition = new Vector2(0f, -8f);
			label.Bold();
			label.Text = page.Header;
			headerCount = UiKit.CreateLabel("headerCount", (Transform)(object)container, 13f, UiKit.TextDim, (TextAnchor)5);
			headerCount.Rect.anchorMin = new Vector2(0f, 1f);
			headerCount.Rect.anchorMax = new Vector2(1f, 1f);
			headerCount.Rect.pivot = new Vector2(0.5f, 1f);
			headerCount.Rect.sizeDelta = new Vector2(-24f, 30f);
			headerCount.Rect.anchoredPosition = new Vector2(0f, -8f);
			Tuple<Scrollbar, float> tuple = CloneGameScrollbar(container, subPanel);
			float num2 = ((tuple != null) ? Mathf.Max(12f, tuple.Item2) : 12f);
			GameObject val = new GameObject("viewport");
			val.transform.SetParent((Transform)(object)container, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.offsetMin = new Vector2(12f, 48f);
			val2.offsetMax = new Vector2(-12f - num2 - 4f, -46f);
			val.AddComponent<RectMask2D>();
			((Graphic)val.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.004f);
			float num3 = num - 24f - num2 - 4f;
			GameObject val3 = new GameObject("content");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = new Vector2(0.5f, 1f);
			val4.anchorMax = new Vector2(0.5f, 1f);
			val4.pivot = new Vector2(0.5f, 1f);
			float num4 = page.BuildGrid(val4, num3);
			val4.sizeDelta = new Vector2(num3, num4);
			ScrollRect val5 = val.AddComponent<ScrollRect>();
			val5.viewport = val2;
			val5.content = val4;
			val5.horizontal = false;
			val5.vertical = true;
			val5.movementType = (MovementType)2;
			val5.scrollSensitivity = 40f;
			if (tuple != null)
			{
				RectTransform val6 = (RectTransform)((Component)tuple.Item1).transform;
				val6.anchorMin = new Vector2(1f, 0f);
				val6.anchorMax = new Vector2(1f, 1f);
				val6.pivot = new Vector2(1f, 0.5f);
				val6.offsetMin = new Vector2(-12f - num2, 48f);
				val6.offsetMax = new Vector2(-12f, -46f);
				val5.verticalScrollbar = tuple.Item1;
				val5.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			}
			footer = UiKit.CreateLabel("footer", (Transform)(object)container, 12f, UiKit.TextDim, (TextAnchor)3);
			footer.Rect.anchorMin = new Vector2(0f, 0f);
			footer.Rect.anchorMax = new Vector2(1f, 0f);
			footer.Rect.pivot = new Vector2(0.5f, 0f);
			footer.Rect.sizeDelta = new Vector2(-124f, 38f);
			footer.Rect.anchoredPosition = new Vector2(-50f, 5f);
			footer.WrapClipped();
			CreateCloseButton(container, styleDonorButton);
			page.Refresh();
		}

		private static Tuple<Scrollbar, float> CloneGameScrollbar(RectTransform container, RectTransform subPanel)
		{
			//IL_0097: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			try
			{
				Transform val = null;
				Transform val2 = (Transform)(object)subPanel;
				Transform val3 = (Transform)(object)subPanel;
				while ((Object)(object)val3 != (Object)null)
				{
					if (((Object)val3).name == "SubPanelArea")
					{
						val2 = val3;
						break;
					}
					val3 = val3.parent;
				}
				if ((Object)(object)val2 == (Object)null)
				{
					return null;
				}
				Scrollbar[] componentsInChildren = ((Component)val2).GetComponentsInChildren<Scrollbar>(true);
				foreach (Scrollbar val4 in componentsInChildren)
				{
					if (((Object)val4).name.Contains("Scrollbar"))
					{
						val = ((Component)val4).transform;
						break;
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				Rect rect = ((RectTransform)val).rect;
				float width = ((Rect)(ref rect)).width;
				GameObject val5 = Object.Instantiate<GameObject>(((Component)val).gameObject, (Transform)(object)container);
				((Object)val5).name = "scrollbar";
				MonoBehaviour[] componentsInChildren2 = val5.GetComponentsInChildren<MonoBehaviour>(true);
				foreach (MonoBehaviour val6 in componentsInChildren2)
				{
					if (!(val6 is Scrollbar) && !(val6 is Image) && !(val6 is Mask) && !(val6 is RectMask2D))
					{
						Object.DestroyImmediate((Object)(object)val6);
					}
				}
				Scrollbar component = val5.GetComponent<Scrollbar>();
				if ((Object)(object)component == (Object)null)
				{
					Object.Destroy((Object)(object)val5);
					return null;
				}
				component.onValueChanged = new ScrollEvent();
				val5.SetActive(true);
				return Tuple.Create<Scrollbar, float>(component, (width > 4f) ? width : 18f);
			}
			catch (Exception ex)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] picker: scrollbar clone failed (" + ex.Message + ")"));
				return null;
			}
		}

		private static void CreateCloseButton(RectTransform container, GameObject donor)
		{
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			GameObject val = null;
			if ((Object)(object)donor != (Object)null)
			{
				try
				{
					val = Object.Instantiate<GameObject>(donor, (Transform)(object)container);
					((Object)val).name = "closeButton";
					LanguageTextMeshController[] componentsInChildren = val.GetComponentsInChildren<LanguageTextMeshController>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
					}
					LayoutElement component = val.GetComponent<LayoutElement>();
					if ((Object)(object)component != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)component);
					}
					HGButton componentInChildren = val.GetComponentInChildren<HGButton>();
					((UnityEventBase)((Button)componentInChildren).onClick).RemoveAllListeners();
					ButtonClickedEvent onClick = ((Button)componentInChildren).onClick;
					object obj = <>O.<0>__Close;
					if (obj == null)
					{
						UnityAction val2 = Close;
						<>O.<0>__Close = val2;
						obj = (object)val2;
					}
					((UnityEvent)onClick).AddListener((UnityAction)obj);
					TMP_Text componentInChildren2 = val.GetComponentInChildren<TMP_Text>();
					if ((Object)(object)componentInChildren2 != (Object)null)
					{
						componentInChildren2.SetText("Close", true);
					}
				}
				catch (Exception ex)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] picker: button clone failed (" + ex.Message + "), using themed button"));
					if ((Object)(object)val != (Object)null)
					{
						Object.Destroy((Object)(object)val);
					}
					val = null;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Image val3 = UiKit.CreatePanel("closeButton", (Transform)(object)container, UiKit.PanelMid);
				UiKit.Stretch(((Graphic)UiKit.CreateOutline("closeOutline", ((Component)val3).transform, UiKit.OutlineBright)).rectTransform);
				ButtonClickedEvent onClick2 = ((Component)val3).gameObject.AddComponent<Button>().onClick;
				object obj2 = <>O.<0>__Close;
				if (obj2 == null)
				{
					UnityAction val4 = Close;
					<>O.<0>__Close = val4;
					obj2 = (object)val4;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
				UiKit.Label label = UiKit.CreateLabel("closeLabel", ((Component)val3).transform, 15f, UiKit.TextPale, (TextAnchor)4);
				UiKit.Stretch(label.Rect);
				label.Text = "Close";
				val = ((Component)val3).gameObject;
			}
			RectTransform component2 = val.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(1f, 0f);
			component2.anchorMax = new Vector2(1f, 0f);
			component2.pivot = new Vector2(1f, 0f);
			component2.sizeDelta = new Vector2(92f, 32f);
			component2.anchoredPosition = new Vector2(-12f, 8f);
		}
	}
	internal static class TitleSystem
	{
		public static readonly string[] Table = new string[74]
		{
			"Rock and Stone Enthusiast", "Did I Hear a Rock and Stone?", "For Karl!", "Leaf Lover", "Mission Control's Headache", "We're Rich!", "Karl Would Be Proud", "Hoxxes Exchange Student", "Banana Slamma", "Full Bananza",
			"Punches Rocks for Fun", "One-Ape Demolition Crew", "Kong-Sized Crater", "Barrels Not Included", "Buried Banana Hoarder", "Certified Ground Remover", "Licensed Blaster", "License Pending", "Crater Connoisseur", "Hole Enthusiast",
			"Amateur Geologist", "Gravel Merchant", "Terrain Adjuster", "Landscape Critic", "OSHA's Most Wanted", "Subsidence Liability", "Erosion, But Faster", "Tectonic Menace", "Big Dig Energy", "Tunnel Visionary",
			"Downward Mobility", "Digs Straight Down", "Bedrock's Bane", "Sediment Sommelier", "Pebble Pusher", "Boulder Whisperer", "Gravity's Coworker", "Spelunker Third Class", "Quarry Quality Assurance", "Unplanned Basement Owner",
			"Negative Space Artist", "Architect of Absence", "Local Earthquake", "Mole Union Representative", "Dust Collector", "It Became a Cube", "One Byte Per Voxel", "Standing on 127.5", "Petrichor V Renovator", "Scorched Earth Policy",
			"The Floor Is Optional", "What Would Karl Do?", "Danger. Darkness. Dwarves.", "Made the Map Worse", "Digs During Boss Fights", "Shortcut Manufacturer", "Fell in Their Own Crater", "Miner, Not a Fighter", "Digging Is a Free Action", "Paid in Blood Money",
			"Redecorates in Red", "Occupational Biohazard", "Forensics Nightmare", "Chunk Salesman", "Overkill Underwriter", "Caution: Slippery Floor", "Swarm Auditor", "Do Not Tap the Glass", "Pebble Parent", "It Lives in a Jar",
			"Emotional Support Boulder", "Tank Custodian", "Grapple Hook Purist", "Lap of Shame"
		};

		private static readonly HashSet<uint> freshUnlocks = new HashSet<uint>();

		private static int lastRolledClearCount = -1;

		private static readonly Random rng = new Random();

		public static void MarkFresh(uint netId)
		{
			freshUnlocks.Add(netId);
		}

		public static int CurrentTitle(NetworkUser nu)
		{
			return UserLifetimeStats.EffectiveTitle(nu);
		}

		public static bool IsFresh(uint netId)
		{
			return freshUnlocks.Contains(netId);
		}

		public static void OnStageAdvance()
		{
			freshUnlocks.Clear();
			Run instance = Run.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			int stageClearCount = instance.stageClearCount;
			if (stageClearCount <= 0)
			{
				lastRolledClearCount = -1;
			}
			else
			{
				if (stageClearCount == lastRolledClearCount)
				{
					return;
				}
				lastRolledClearCount = stageClearCount;
				if (!ModOptions.TitlesEnabled.Value)
				{
					return;
				}
				float value = ModOptions.TitleChance.Value;
				foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
				{
					if ((Object)(object)readOnlyInstances == (Object)null || !((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
					{
						continue;
					}
					string text = UserLifetimeStats.ProfileKey(readOnlyInstances);
					int num;
					int num2;
					if (text != null && UserLifetimeStats.UnlockedTitles(text).Count == 0 && UserLifetimeStats.UnlockedBackgrounds(text).Count == 0)
					{
						num = ((UserLifetimeStats.PendingCount(text) == 0) ? 1 : 0);
						if (num != 0)
						{
							num2 = ((rng.Next(2) == 0) ? 1 : 0);
							goto IL_00ce;
						}
					}
					else
					{
						num = 0;
					}
					num2 = 0;
					goto IL_00ce;
					IL_00ce:
					bool flag = (byte)num2 != 0;
					bool flag2 = num != 0 && !flag;
					if (flag || rng.NextDouble() < (double)value)
					{
						int num3 = UserLifetimeStats.DrawRandomTitle(readOnlyInstances, rng, Table.Length);
						if (num3 >= 0)
						{
							UserLifetimeStats.EnqueuePending(text, 0, num3);
							ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] " + readOnlyInstances.userName + " won the title '" + Table[num3] + "'" + (flag ? " (first treasure, guaranteed)" : "") + " — queued for the reveal"));
						}
						else
						{
							ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] " + readOnlyInstances.userName + " rolled a title win but owns every title already — nothing to award"));
						}
					}
					if (flag2 || rng.NextDouble() < (double)value)
					{
						int num4 = BackgroundSystem.QueueRandomPattern(readOnlyInstances, rng);
						if (num4 >= 0)
						{
							ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] " + readOnlyInstances.userName + " won the card background '" + BackgroundSystem.Table[num4].name + "'" + (flag2 ? " (first treasure, guaranteed)" : "") + " — queued for the reveal"));
						}
						else
						{
							ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] " + readOnlyInstances.userName + " rolled a card-background win but every pattern is unlocked already — nothing to award"));
						}
					}
				}
			}
		}

		public static void OnRunEnd()
		{
			freshUnlocks.Clear();
			lastRolledClearCount = -1;
		}
	}
	internal static class UserLifetimeStats
	{
		private static Dictionary<string, double> totals;

		private static Dictionary<string, List<int>> titles;

		private static Dictionary<string, int> chosenTitle;

		private static Dictionary<string, List<int>> bgUnlocks;

		private static Dictionary<string, int> chosenBg;

		private static Dictionary<string, List<int>> arcadeColors;

		private static Dictionary<string, int> runnerBest;

		private static Dictionary<string, double> wormsDug;

		private static Dictionary<string, double> raceLap;

		private static Dictionary<string, double> petEaten;

		private static Dictionary<string, long> petSeed;

		private static Dictionary<string, string> petTank;

		private static Dictionary<string, string> petCanister;

		private static Dictionary<string, int> petPrestige;

		private static Dictionary<string, int> petRolled;

		private static Dictionary<string, List<int>> nameFxUnlocks;

		private static Dictionary<string, int> chosenNameFx;

		private static Dictionary<string, List<int>> pendingUnlocks;

		private static readonly Dictionary<uint, float> bankedRun = new Dictionary<uint, float>();

		private static bool dirty;

		private static bool loaded;

		private static float lastFlush = float.NegativeInfinity;

		private static string FilePath => Path.Combine(Paths.ConfigPath, "com.Xerdi.ScorchedVoxels.UserStats.cfg");

		private static void EnsureLoaded()
		{
			if (loaded)
			{
				return;
			}
			if (totals == null)
			{
				totals = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
				titles = new Dictionary<string, List<int>>(StringComparer.OrdinalIgnoreCase);
				chosenTitle = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
				bgUnlocks = new Dictionary<string, List<int>>(StringComparer.OrdinalIgnoreCase);
				chosenBg = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
				arcadeColors = new Dictionary<string, List<int>>(StringComparer.OrdinalIgnoreCase);
				runnerBest = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
				wormsDug = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
				raceLap = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
				petEaten = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
				petSeed = new Dictionary<string, long>(StringComparer.OrdinalIgnoreCase);
				petTank = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				petCanister = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				petPrestige = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
				petRolled = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
				nameFxUnlocks = new Dictionary<string, List<int>>(StringComparer.OrdinalIgnoreCase);
				chosenNameFx = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
				pendingUnlocks = new Dictionary<string, List<int>>(StringComparer.OrdinalIgnoreCase);
			}
			try
			{
				if (!File.Exists(FilePath))
				{
					loaded = true;
					return;
				}
				string[] array = File.ReadAllLines(FilePath);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.Length == 0 || text[0] == '#')
					{
						continue;
					}
					int num = text.LastIndexOf('=');
					if (num <= 0)
					{
						continue;
					}
					string text2 = text.Substring(0, num).Trim();
					string text3 = text.Substring(num + 1).Trim();
					if (text2.Length == 0)
					{
						continue;
					}
					int num2 = text2.LastIndexOf('.');
					string key = ((num2 >= 0) ? text2.Substring(0, num2) : null);
					string suffix = ((num2 >= 0) ? text2.Substring(num2 + 1) : null);
					double result11;
					if (SuffixIs(suffix, "titles"))
					{
						List<int> list = ParseIntList(text3);
						if (list.Count > 0)
						{
							titles[key] = list;
						}
					}
					else if (SuffixIs(suffix, "bgs"))
					{
						List<int> list2 = ParseIntList(text3);
						if (list2.Count > 0)
						{
							bgUnlocks[key] = list2;
						}
					}
					else if (SuffixIs(suffix, "arcadecolors"))
					{
						List<int> list3 = ParseIntList(text3);
						if (list3.Count > 0)
						{
							arcadeColors[key] = list3;
						}
					}
					else if (SuffixIs(suffix, "runbest"))
					{
						if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 0)
						{
							runnerBest[key] = result;
						}
					}
					else if (SuffixIs(suffix, "wormsdug"))
					{
						if (double.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && result2 > 0.0)
						{
							wormsDug[key] = result2;
						}
					}
					else if (SuffixIs(suffix, "racelap"))
					{
						if (double.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) && result3 > 0.0)
						{
							raceLap[key] = result3;
						}
					}
					else if (SuffixIs(suffix, "peteaten"))
					{
						if (double.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result4) && result4 >= 0.0)
						{
							petEaten[key] = result4;
						}
					}
					else if (SuffixIs(suffix, "petseed"))
					{
						if (long.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result5) && result5 > 0)
						{
							petSeed[key] = result5;
						}
					}
					else if (SuffixIs(suffix, "pettank"))
					{
						if (text3.Length > 0)
						{
							petTank[key] = text3;
						}
					}
					else if (SuffixIs(suffix, "petcanister"))
					{
						if (text3.Length > 0)
						{
							petCanister[key] = text3;
						}
					}
					else if (SuffixIs(suffix, "petprestige"))
					{
						if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result6) && result6 > 0)
						{
							petPrestige[key] = result6;
						}
					}
					else if (SuffixIs(suffix, "petrolled"))
					{
						if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result7) && result7 > 0)
						{
							petRolled[key] = result7;
						}
					}
					else if (SuffixIs(suffix, "namefx"))
					{
						List<int> list4 = ParseIntList(text3);
						if (list4.Count > 0)
						{
							nameFxUnlocks[key] = list4;
						}
					}
					else if (SuffixIs(suffix, "namefxpick"))
					{
						if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result8) && result8 >= 0)
						{
							chosenNameFx[key] = result8;
						}
					}
					else if (SuffixIs(suffix, "pending"))
					{
						List<int> list5 = ParsePendingList(text3);
						if (list5.Count > 0)
						{
							pendingUnlocks[key] = list5;
						}
					}
					else if (SuffixIs(suffix, "bgchosen"))
					{
						if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result9) && result9 >= 0)
						{
							chosenBg[key] = result9;
						}
					}
					else if (SuffixIs(suffix, "chosen"))
					{
						if (int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result10) && result10 >= 0)
						{
							chosenTitle[key] = result10;
						}
					}
					else if (double.TryParse(text3, NumberStyles.Float, CultureInfo.InvariantCulture, out result11) && result11 >= 0.0)
					{
						totals[text2] = result11;
					}
				}
				loaded = true;
			}
			catch (Exception ex)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] could not read user stats file (will retry): " + ex.Message));
			}
		}

		internal static string ProfileKey(NetworkUser nu)
		{
			return ProfileKey(((Object)(object)nu != (Object)null) ? nu.localUser : null);
		}

		internal static string ProfileKey(LocalUser lu)
		{
			UserProfile val = ((lu != null) ? lu.userProfile : null);
			if (val == null)
			{
				return null;
			}
			if (!string.IsNullOrEmpty(val.fileName))
			{
				return val.fileName;
			}
			if (!string.IsNullOrEmpty(val.name))
			{
				return val.name;
			}
			return null;
		}

		public static double GetRunBase(NetworkUser nu)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			EnsureLoaded();
			string text = ProfileKey(nu);
			if (text == null)
			{
				return 0.0;
			}
			totals.TryGetValue(text, out var value);
			Dictionary<uint, float> dictionary = bankedRun;
			NetworkInstanceId netId = ((NetworkBehaviour)nu).netId;
			dictionary.TryGetValue(((NetworkInstanceId)(ref netId)).Value, out var value2);
			return value - (double)value2;
		}

		public static void Bank()
		{
			//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)
			EnsureLoaded();
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances == (Object)null || !((NetworkBehaviour)readOnlyInstances).isLocalPlayer)
				{
					continue;
				}
				string text = ProfileKey(readOnlyInstances);
				if (text != null)
				{
					NetworkInstanceId netId = ((NetworkBehaviour)readOnlyInstances).netId;
					uint value = ((NetworkInstanceId)(ref netId)).Value;
					float num = (NetworkServer.active ? CarveStats.GetRun(value) : (LoadingRoster.Find(value)?.m3Run ?? 0f));
					bankedRun.TryGetValue(value, out var value2);
					if (!(num <= value2))
					{
						totals.TryGetValue(text, out var value3);
						totals[text] = value3 + (double)(num - value2);
						bankedRun[value] = num;
						dirty = true;
					}
				}
			}
			if (Time.realtimeSinceStartup - lastFlush > 60f)
			{
				Flush();
			}
		}

		private static bool SuffixIs(string suffix, string name)
		{
			return suffix?.Equals(name, StringComparison.OrdinalIgnoreCase) ?? false;
		}

		private static List<int> ParseIntList(string val)
		{
			List<int> list = new List<int>();
			string[] array = val.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				if (int.TryParse(array[i].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result >= 0 && !list.Contains(result))
				{
					list.Add(result);
				}
			}
			return list;
		}

		public static int WornCosmetic(int pick, bool pickOwned, IReadOnlyList<int> unlockedInOrder, int defaultIdx)
		{
			if (pick >= 0 && pickOwned)
			{
				return pick;
			}
			if (unlockedInOrder.Count <= 0)
			{
				return defaultIdx;
			}
			return unlockedInOrder[unlockedInOrder.Count - 1];
		}

		public static int DrawLockedIndex(Random rng, int tableLength, Predicate<int> owns)
		{
			List<int> list = new List<int>();
			for (int i = 0; i < tableLength; i++)
			{
				if (!owns(i))
				{
					list.Add(i);
				}
			}
			if (list.Count != 0)
			{
				return list[rng.Next(list.Count)];
			}
			return -1;
		}

		private static bool Contains(IReadOnlyList<int> list, int v)
		{
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i] == v)
				{
					return true;
				}
			}
			return false;
		}

		public static IReadOnlyList<int> UnlockedBackgrounds(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !bgUnlocks.TryGetValue(profileKey, out var value))
			{
				return Array.Empty<int>();
			}
			return value;
		}

		public static void AddBackground(string profileKey, int idx)
		{
			EnsureLoaded();
			if (profileKey != null && idx >= 0)
			{
				if (!bgUnlocks.TryGetValue(profileKey, out var value))
				{
					value = (bgUnlocks[profileKey] = new List<int>());
				}
				if (!value.Contains(idx))
				{
					value.Add(idx);
					dirty = true;
					Flush();
				}
			}
		}

		public static int GetChosenBackground(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !chosenBg.TryGetValue(profileKey, out var value))
			{
				return -1;
			}
			return value;
		}

		public static void SetChosenBackground(string profileKey, int idx)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				if (idx < 0)
				{
					chosenBg.Remove(profileKey);
				}
				else
				{
					chosenBg[profileKey] = idx;
				}
				dirty = true;
				Flush();
			}
		}

		public static IReadOnlyList<int> ArcadeColors(NetworkUser nu)
		{
			return ArcadeColors(ProfileKey(nu));
		}

		public static IReadOnlyList<int> ArcadeColors(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !arcadeColors.TryGetValue(profileKey, out var value))
			{
				return Array.Empty<int>();
			}
			return value;
		}

		public static void SetArcadeColors(string profileKey, IReadOnlyList<int> ranked)
		{
			EnsureLoaded();
			if (profileKey == null)
			{
				return;
			}
			List<int> list = new List<int>(3);
			if (ranked != null)
			{
				foreach (int item in ranked)
				{
					if (item >= 0 && item < 16 && !list.Contains(item))
					{
						list.Add(item);
						if (list.Count == 3)
						{
							break;
						}
					}
				}
			}
			if (list.Count == 0)
			{
				arcadeColors.Remove(profileKey);
			}
			else
			{
				arcadeColors[profileKey] = list;
			}
			dirty = true;
			Flush();
			StageSyncCoordinator.OnLocalCardMetaChanged();
		}

		public static int RunnerBest(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !runnerBest.TryGetValue(profileKey, out var value))
			{
				return 0;
			}
			return value;
		}

		public static void ReportRunnerScore(string profileKey, int score)
		{
			EnsureLoaded();
			if (profileKey != null && score > 0)
			{
				runnerBest.TryGetValue(profileKey, out var value);
				if (score > value)
				{
					runnerBest[profileKey] = score;
					dirty = true;
					Flush();
					StageSyncCoordinator.OnLocalCardMetaChanged();
				}
			}
		}

		public static double WormsDug(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !wormsDug.TryGetValue(profileKey, out var value))
			{
				return 0.0;
			}
			return value;
		}

		public static void AddWormsDug(string profileKey, double blocks)
		{
			EnsureLoaded();
			if (profileKey != null && !(blocks <= 0.0))
			{
				wormsDug.TryGetValue(profileKey, out var value);
				wormsDug[profileKey] = value + blocks;
				dirty = true;
			}
		}

		public static float RaceBestLap(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !raceLap.TryGetValue(profileKey, out var value))
			{
				return 0f;
			}
			return (float)value;
		}

		public static void ReportRaceLap(string profileKey, float seconds)
		{
			EnsureLoaded();
			if (profileKey != null && !(seconds <= 0f) && (!raceLap.TryGetValue(profileKey, out var value) || !((double)seconds >= value)))
			{
				raceLap[profileKey] = seconds;
				dirty = true;
				Flush();
			}
		}

		public static int EffectiveTitle(NetworkUser nu)
		{
			return EffectiveTitle(ProfileKey(nu));
		}

		public static int EffectiveTitle(string profileKey)
		{
			EnsureLoaded();
			IReadOnlyList<int> readOnlyList = UnlockedTitles(profileKey);
			int num = GetChosenTitle(profileKey);
			return WornCosmetic(num, Contains(readOnlyList, num), readOnlyList, -1);
		}

		public static IReadOnlyList<int> UnlockedTitles(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !titles.TryGetValue(profileKey, out var value))
			{
				return Array.Empty<int>();
			}
			return value;
		}

		public static int GetChosenTitle(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !chosenTitle.TryGetValue(profileKey, out var value))
			{
				return -1;
			}
			return value;
		}

		public static void SetChosenTitle(string profileKey, int titleIdx)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				if (titleIdx < 0)
				{
					chosenTitle.Remove(profileKey);
				}
				else
				{
					chosenTitle[profileKey] = titleIdx;
				}
				dirty = true;
				Flush();
			}
		}

		public static int DrawRandomTitle(NetworkUser nu, Random rng, int tableLength)
		{
			EnsureLoaded();
			string key = ProfileKey(nu);
			if (key == null)
			{
				return -1;
			}
			IReadOnlyList<int> owned = UnlockedTitles(key);
			return DrawLockedIndex(rng, tableLength, (int i) => Contains(owned, i) || PendingContains(key, 0, i));
		}

		public static double PetEaten(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !petEaten.TryGetValue(profileKey, out var value))
			{
				return 0.0;
			}
			return value;
		}

		public static void SetPetEaten(string profileKey, double eaten)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				petEaten[profileKey] = eaten;
				dirty = true;
			}
		}

		public static uint PetSeed(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !petSeed.TryGetValue(profileKey, out var value))
			{
				return 0u;
			}
			return (uint)value;
		}

		public static void SetPetSeed(string profileKey, uint seed)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				petSeed[profileKey] = seed;
				dirty = true;
				Flush();
			}
		}

		public static string TankGrid(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !petTank.TryGetValue(profileKey, out var value))
			{
				return null;
			}
			return value;
		}

		public static void SetTankGrid(string profileKey, string token)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				petTank[profileKey] = token ?? "";
				dirty = true;
			}
		}

		public static string PetCanister(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !petCanister.TryGetValue(profileKey, out var value))
			{
				return null;
			}
			return value;
		}

		public static void SetPetCanister(string profileKey, string token)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				if (string.IsNullOrEmpty(token))
				{
					petCanister.Remove(profileKey);
				}
				else
				{
					petCanister[profileKey] = token;
				}
				dirty = true;
			}
		}

		public static int PetPrestigeUsed(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !petPrestige.TryGetValue(profileKey, out var value))
			{
				return 0;
			}
			return value;
		}

		public static void SetPetPrestigeUsed(string profileKey, int rolls)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				petPrestige[profileKey] = rolls;
				dirty = true;
			}
		}

		public static int PetRolledStage(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !petRolled.TryGetValue(profileKey, out var value))
			{
				return 0;
			}
			return value;
		}

		public static void SetPetRolledStage(string profileKey, int stage)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				petRolled[profileKey] = stage;
				dirty = true;
			}
		}

		public static IReadOnlyList<int> UnlockedNameFx(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !nameFxUnlocks.TryGetValue(profileKey, out var value))
			{
				return Array.Empty<int>();
			}
			return value;
		}

		public static bool UnlockNameFx(string profileKey, int idx)
		{
			EnsureLoaded();
			if (profileKey == null || idx < 0)
			{
				return false;
			}
			if (!nameFxUnlocks.TryGetValue(profileKey, out var value))
			{
				value = (nameFxUnlocks[profileKey] = new List<int>());
			}
			if (value.Contains(idx))
			{
				return false;
			}
			value.Add(idx);
			dirty = true;
			Flush();
			return true;
		}

		public static int GetChosenNameFx(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !chosenNameFx.TryGetValue(profileKey, out var value))
			{
				return -1;
			}
			return value;
		}

		public static void SetChosenNameFx(string profileKey, int idx)
		{
			EnsureLoaded();
			if (profileKey != null)
			{
				if (idx < 0)
				{
					chosenNameFx.Remove(profileKey);
				}
				else
				{
					chosenNameFx[profileKey] = idx;
				}
				dirty = true;
				Flush();
				StageSyncCoordinator.OnLocalCardMetaChanged();
			}
		}

		public static int EffectiveNameFx(string profileKey)
		{
			EnsureLoaded();
			IReadOnlyList<int> readOnlyList = UnlockedNameFx(profileKey);
			int num = GetChosenNameFx(profileKey);
			return WornCosmetic(num, Contains(readOnlyList, num), readOnlyList, -1);
		}

		private static int PackPending(byte kind, int idx)
		{
			return (kind << 24) | idx;
		}

		private static List<int> ParsePendingList(string val)
		{
			List<int> list = new List<int>();
			string[] array = val.Split(',');
			foreach (string text in array)
			{
				int num = text.IndexOf(':');
				if (num > 0 && int.TryParse(text.Substring(0, num).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && int.TryParse(text.Substring(num + 1).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && result >= 0 && result < 256 && result2 >= 0)
				{
					int item = PackPending((byte)result, result2);
					if (!list.Contains(item))
					{
						list.Add(item);
					}
				}
			}
			return list;
		}

		public static int PendingCount(string profileKey)
		{
			EnsureLoaded();
			if (profileKey == null || !pendingUnlocks.TryGetValue(profileKey, out var value))
			{
				return 0;
			}
			return value.Count;
		}

		public static bool TryPeekPending(string profileKey, out byte kind, out int idx)
		{
			EnsureLoaded();
			kind = 0;
			idx = -1;
			if (profileKey == null || !pendingUnlocks.TryGetValue(profileKey, out var value) || value.Count == 0)
			{
				return false;
			}
			kind = (byte)(value[0] >> 24);
			idx = value[0] & 0xFFFFFF;
			return true;
		}

		public static bool PendingContains(string profileKey, byte kind, int idx)
		{
			EnsureLoaded();
			if (profileKey != null && pendingUnlocks.TryGetValue(profileKey, out var value))
			{
				return value.Contains(PackPending(kind, idx));
			}
			return false;
		}

		public static void EnqueuePending(string profileKey, byte kind, int idx)
		{
			EnsureLoaded();
			if (profileKey != null && idx >= 0)
			{
				if (!pendingUnlocks.TryGetValue(profileKey, out var value))
				{
					value = (pendingUnlocks[profileKey] = new List<int>());
				}
				int item = PackPending(kind, idx);
				if (!value.Contains(item))
				{
					value.Add(item);
					dirty = true;
					Flush();
				}
			}
		}

		public static bool DequeuePending(string profileKey, byte kind, int idx)
		{
			EnsureLoaded();
			if (profileKey == null || !pendingUnlocks.TryGetValue(profileKey, out var value))
			{
				return false;
			}
			if (!value.Remove(PackPending(kind, idx)))
			{
				return false;
			}
			if (value.Count == 0)
			{
				pendingUnlocks.Remove(profileKey);
			}
			dirty = true;
			Flush();
			return true;
		}

		public static void AddTitle(string profileKey, int idx)
		{
			EnsureLoaded();
			if (profileKey != null && idx >= 0)
			{
				if (!titles.TryGetValue(profileKey, out var value))
				{
					value = (titles[profileKey] = new List<int>());
				}
				if (!value.Contains(idx))
				{
					value.Add(idx);
					dirty = true;
					Flush();
				}
			}
		}

		public static void OnStageAdvance()
		{
			Bank();
			Flush();
		}

		public static void OnRunEnd()
		{
			Bank();
			Flush();
			bankedRun.Clear();
		}

		private static void Flush()
		{
			lastFlush = Time.realtimeSinceStartup;
			if (!dirty || !loaded)
			{
				return;
			}
			try
			{
				List<string> list = new List<string> { "# ScorchedVoxels lifetime carved terrain (m³) per user profile.", "# Feeds the loading-screen portrait rim: bronze 1e6, silver 1e7, gold 1e8, platinum 1e9.", "# <profile>.titles = unlocked title indices (unlock order); <profile>.chosen = picked title.", "# <profile>.bgs = unlocked pattern backgrounds; <profile>.bgchosen = picked card background.", "# <profile>.arcadecolors = ranked arcade colorway picks, favorite first." };
				foreach (KeyValuePair<string, double> total in totals)
				{
					list.Add(total.Key + " = " + total.Value.ToString("R", CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, List<int>> title in titles)
				{
					if (title.Value.Count > 0)
					{
						list.Add(title.Key + ".titles = " + string.Join(",", title.Value));
					}
				}
				foreach (KeyValuePair<string, int> item in chosenTitle)
				{
					list.Add(item.Key + ".chosen = " + item.Value.ToString(CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, List<int>> bgUnlock in bgUnlocks)
				{
					if (bgUnlock.Value.Count > 0)
					{
						list.Add(bgUnlock.Key + ".bgs = " + string.Join(",", bgUnlock.Value));
					}
				}
				foreach (KeyValuePair<string, int> item2 in chosenBg)
				{
					list.Add(item2.Key + ".bgchosen = " + item2.Value.ToString(CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, List<int>> arcadeColor in arcadeColors)
				{
					if (arcadeColor.Value.Count > 0)
					{
						list.Add(arcadeColor.Key + ".arcadecolors = " + string.Join(",", arcadeColor.Value));
					}
				}
				foreach (KeyValuePair<string, int> item3 in runnerBest)
				{
					list.Add(item3.Key + ".runbest = " + item3.Value.ToString(CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, double> item4 in wormsDug)
				{
					list.Add(item4.Key + ".wormsdug = " + item4.Value.ToString("R", CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, double> item5 in raceLap)
				{
					list.Add(item5.Key + ".racelap = " + item5.Value.ToString("R", CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, double> item6 in petEaten)
				{
					list.Add(item6.Key + ".peteaten = " + item6.Value.ToString("R", CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, long> item7 in petSeed)
				{
					list.Add(item7.Key + ".petseed = " + item7.Value.ToString(CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, string> item8 in petTank)
				{
					if (!string.IsNullOrEmpty(item8.Value))
					{
						list.Add(item8.Key + ".pettank = " + item8.Value);
					}
				}
				foreach (KeyValuePair<string, string> item9 in petCanister)
				{
					if (!string.IsNullOrEmpty(item9.Value))
					{
						list.Add(item9.Key + ".petcanister = " + item9.Value);
					}
				}
				foreach (KeyValuePair<string, int> item10 in petPrestige)
				{
					list.Add(item10.Key + ".petprestige = " + item10.Value.ToString(CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, int> item11 in petRolled)
				{
					list.Add(item11.Key + ".petrolled = " + item11.Value.ToString(CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, List<int>> nameFxUnlock in nameFxUnlocks)
				{
					if (nameFxUnlock.Value.Count > 0)
					{
						list.Add(nameFxUnlock.Key + ".namefx = " + string.Join(",", nameFxUnlock.Value));
					}
				}
				foreach (KeyValuePair<string, int> item12 in chosenNameFx)
				{
					list.Add(item12.Key + ".namefxpick = " + item12.Value.ToString(CultureInfo.InvariantCulture));
				}
				foreach (KeyValuePair<string, List<int>> pendingUnlock in pendingUnlocks)
				{
					if (pendingUnlock.Value.Count == 0)
					{
						continue;
					}
					StringBuilder stringBuilder = new StringBuilder();
					foreach (int item13 in pendingUnlock.Value)
					{
						if (stringBuilder.Length > 0)
						{
							stringBuilder.Append(',');
						}
						stringBuilder.Append(item13 >> 24).Append(':').Append(item13 & 0xFFFFFF);
					}
					list.Add($"{pendingUnlock.Key}.pending = {stringBuilder}");
				}
				File.WriteAllLines(FilePath, list);
				dirty = false;
			}
			catch (Exception ex)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] could not write user stats file: " + ex.Message));
			}
		}
	}
	internal static class MainThread
	{
		private static readonly ConcurrentQueue<Action> queue = new ConcurrentQueue<Action>();

		public static void Post(Action action)
		{
			queue.Enqueue(action);
		}

		public static void Pump()
		{
			Action result;
			while (queue.TryDequeue(out result))
			{
				try
				{
					result();
				}
				catch (Exception arg)
				{
					ScorchedVoxelsPlugin.Log.LogError((object)$"Main-thread callback failed: {arg}");
				}
			}
		}
	}
	internal static class ModOptions
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Toggle;

			public static UnityAction <1>__ToggleBackgrounds;

			public static UnityAction <2>__ToggleArcadeColors;

			public static UnityAction <3>__ToggleNames;
		}

		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<float> VoxelSize;

		internal static ConfigEntry<float> RadiusMultiplier;

		internal static ConfigEntry<float> MinBlastRadius;

		internal static ConfigEntry<float> MaxCarveRadius;

		internal static ConfigEntry<bool> MeleeCarving;

		internal static ConfigEntry<bool> CoarseCollision;

		internal static ConfigEntry<string> ExcludedNames;

		internal static ConfigEntry<float> MinTerrainSize;

		internal static ConfigEntry<float> LodDistance;

		internal static ConfigEntry<bool> VerboseLogging;

		internal static ConfigEntry<bool> LogTeleporterAssets;

		internal static ConfigEntry<bool> MemoryReport;

		internal static ConfigEntry<bool> TestButtons;

		internal static ConfigEntry<bool> DebrisEnabled;

		internal static ConfigEntry<int> DebrisMaxPieces;

		internal static ConfigEntry<bool> GoreEnabled;

		internal static ConfigEntry<float> BloodAmount;

		internal static ConfigEntry<bool> TitlesEnabled;

		internal static ConfigEntry<float> TitleChance;

		internal static ConfigEntry<bool> RevealSounds;

		internal static ConfigEntry<bool> ArcadeEnabled;

		internal static void Bind(ConfigFile config)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Expected O, but got Unknown
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Expected O, but got Unknown
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Expected O, but got Unknown
			Enabled = config.Bind<bool>("General", "Enabled", true, "Master switch. When off, stages are left vanilla.");
			VoxelSize = config.Bind<float>("Voxels", "VoxelSize", 0.5f, new ConfigDescription("PREFERRED voxel edge length in meters. Smaller = finer terrain and craters but much more memory and longer stage conversion (cost scales ~1/size^2). Maps too large for this size automatically get coarser voxels until they fit — conversion never fails on map size.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			RadiusMultiplier = config.Bind<float>("Carving", "RadiusMultiplier", 0.45f, new ConfigDescription("Carve radius = blast radius * this value.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 2f), Array.Empty<object>()));
			MinBlastRadius = config.Bind<float>("Carving", "MinBlastRadius", 0.5f, "Blasts smaller than this (meters) do not carve.");
			MaxCarveRadius = config.Bind<float>("Carving", "MaxCarveRadius", 25f, "Upper limit on carve radius (meters).");
			MeleeCarving = config.Bind<bool>("Carving", "MeleeCarving", true, "Melee weapons gouge a slot into the terrain when the blade actually passes through it (any survivor or monster using an overlap/melee attack). Server-authoritative: the host decides and broadcasts to clients.");
			CoarseCollision = config.Bind<bool>("Performance", "CoarseCollision", true, "Undisturbed terrain uses one coarse collider per 16 m block (big memory saving). If you clip into or fall through terrain that looks solid, set this to false to give every chunk a full-resolution collider that exactly matches the visuals (uses more memory). Local only, safe to differ between players.");
			ExcludedNames = config.Bind<string>("TerrainSelection", "ExcludedNames", "Water", "Comma-separated fragments (case-insensitive). World meshes whose OBJECT, MATERIAL, or SHADER name contains any of these are not converted (left vanilla).");
			MinTerrainSize = config.Bind<float>("TerrainSelection", "MinTerrainSize", 15f, new ConfigDescription("World meshes whose largest bounding-box dimension is at or below this (meters) are treated as props/platforms — e.g. the teleporter pad — and left as vanilla mesh; larger meshes become voxel terrain. Tune to just above the teleporter pad's size. 0 converts everything regardless of size (may re-introduce the teleporter-pad box). NOTE: maps with small modular terrain pieces may need this lowered.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			LodDistance = config.Bind<float>("Performance", "LodDistance", 90f, new ConfigDescription("Beyond this distance (meters) a 32m block of terrain renders as ONE quarter-detail mesh instead of 8 full-detail chunks; beyond 2.5x this distance a 64m block renders as one sixteenth-detail mesh — far fewer draw calls and triangles. Colliders always stay full detail. 0 disables LOD.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 500f), Array.Empty<object>()));
			VerboseLogging = config.Bind<bool>("Debug", "VerboseLogging", false, "Log conversion and carve activity. Console writes are slow — leave off unless debugging.");
			LogTeleporterAssets = config.Bind<bool>("Debug", "LogTeleporterAssets", false, "DIAGNOSTIC, one-shot per stage: logs the ENTIRE teleporter hierarchy (every child object, its mesh name, and bounding-box size in meters). Hundreds of log lines per stage — leave off unless hunting a teleporter asset.");
			MemoryReport = config.Bind<bool>("Debug", "MemoryReport", false, "DIAGNOSTIC, one-shot per stage: after a stage finishes converting, logs a breakdown of the mod's RAM use (chunk meshes, colliders, density, retained source meshes, winding fields) to find memory hogs. A dozen log lines per stage — leave off unless investigating memory.");
			TestButtons = config.Bind<bool>("Debug", "TestButtons", false, "DEVELOPER: F7 spawns a Golem near the player (host/singleplayer only), F8 saves a gore debug dump (every renderer's transforms, materials, meshes and bones, gore state, the last cuts' full inputs, plus a screenshot) to BepInEx/ScorchedVoxelsDumps for offline analysis, F9 spawns one MAGMA WORM per element and kills each with that element forced - the deliberate worst-case gore stress test (hold Shift for the overkill versions; host/singleplayer only), F10 bites a chunk out of the living enemy under the crosshair (hold Shift for a big one; local-only — it spends the shared 3-bite budget, so it skews sync observations), F11 with the terrarium open dumps 200k m³ of random dirt into the canister (Shift+F11 cycles the pet's shader-skin foil: Voidskin, Chef's Fire, off; Ctrl+F11 prospects the next loaded fire material onto Chef's Fire and logs its name). While on, cut inputs are recorded in RAM, the gore census prints every 20s, and deaths/cuts spending 25ms+ log themselves. Leave off in normal play.");
			DebrisEnabled = config.Bind<bool>("Effects", "DebrisEnabled", true, "Visual-only rock chunks that fly out of carves and fall through the map. No colliders, no physics — a handful of transform updates per frame.");
			DebrisMaxPieces = config.Bind<int>("Effects", "DebrisMaxPieces", 30, new ConfigDescription("Hard cap on debris pieces alive at once; new bursts recycle the oldest pieces past this. Each piece costs one raycast per frame until its single bounce.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(4, 30), Array.Empty<object>()));
			GoreEnabled = config.Bind<bool>("Effects", "GoreEnabled", false, "EXPERIMENTAL, off by default. Comic gore: kills splash blood decals onto the terrain, and dead bodies become voxelized corpses that the killing blow rips apart — explosions blow them into flying wedges, blades cut them in half, bullets punch through and bleed them. Corpses erode from the same blasts and swings that carve terrain. Purely cosmetic; corpse shapes are local to each machine and never affect gameplay outcomes. Performance in very large fights is still being tuned.");
			BloodAmount = config.Bind<float>("Effects", "BloodAmount", 1f, new ConfigDescription("Blood splatter multiplier: how many blood decals a kill, a landing gib, and a bullet throw down. 1 is the default; raise it for a messier scene, lower it for a lighter touch. Only the number of splatters scales — their size and the corpse cutting are unchanged, and the batch caps still hold, so cranking this up can never run away. In multiplayer the host's value applies to everyone so the mess looks the same on every screen. Purely cosmetic.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 4f), Array.Empty<object>()));
			TitlesEnabled = config.Bind<bool>("Titles", "TitlesEnabled", true, "Every finished level rolls a chance to unlock a cosmetic title (random pick from the ones you don't own yet). Titles persist per user profile and show ONLY on the loading-screen player cards.");
			TitleChance = config.Bind<float>("Titles", "TitleChance", 0.08f, new ConfigDescription("Chance per finished level to win a title, and (separate independent roll) a card background pattern. Wins queue and unlock when their reveal reel lands. Rolled locally per player — purely cosmetic, so it doesn't need to match between machines.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			RevealSounds = config.Bind<bool>("Titles", "RevealSounds", true, "Sound effects for the loading-screen prize reel (spin-up shutter, per-tile tick, unlock chime), borrowed from the game's own UI soundbank. Always ONE shared sound source — four simultaneous winners are exactly as loud as one.");
			ArcadeEnabled = config.Bind<bool>("Arcade", "ArcadeEnabled", true, "Minigames on the loading screen while the stage converts. Purely local UI on top of the loading overlay — turning it off changes nothing about terrain or networking.");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void SetupRiskOfOptions()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_001e: 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)
			//IL_002e: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_009a: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00f0: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_014b: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: 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_0170: 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_0186: 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_01a1: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_0203: 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_020e: Expected O, but got Unknown
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Expected O, but got Unknown
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Expected O, but got Unknown
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Expected O, but got Unknown
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Expected O, but got Unknown
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Expected O, but got Unknown
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			ModSettingsManager.SetModDescription("Destructible voxel terrain — explosions carve real craters. Terrain settings apply from the NEXT stage; in multiplayer the host's terrain settings win. Advanced and debug settings live in the config file.");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(Enabled));
			ModSettingsManager.AddOption((BaseOption)new StepSliderOption(VoxelSize, new StepSliderConfig
			{
				name = "Voxel Size",
				category = "General",
				description = "Terrain resolution in meters. Smaller = finer terrain and craters, but more memory and longer stage loads. Maps too large for the chosen size automatically use coarser voxels.",
				min = 0.5f,
				max = 2f,
				increment = 0.05f
			}));
			ModSettingsManager.AddOption((BaseOption)new StepSliderOption(RadiusMultiplier, new StepSliderConfig
			{
				name = "Crater Size",
				category = "General",
				description = "How big a crater an explosion digs, as a fraction of its blast radius. The host's value applies to the whole lobby.",
				min = 0.25f,
				max = 1f,
				increment = 0.05f
			}));
			ModSettingsManager.AddOption((BaseOption)new StepSliderOption(LodDistance, new StepSliderConfig
			{
				name = "Terrain Detail Distance",
				category = "General",
				description = "Beyond this many meters, far terrain renders as merged lower-detail meshes (big draw-call saving). Craters and colliders always stay exact. 0 disables the saving entirely — slowest, only for troubleshooting.",
				min = 0f,
				max = 500f,
				increment = 5f
			}));
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(GoreEnabled, new CheckBoxConfig
			{
				name = "Comic Gore",
				category = "Gore",
				description = "Kills splash blood, corpses ragdoll and get cut apart by whatever killed them, and elemental kills stage their element — acid dissolves, fire chars, ice shatters, lightning arcs. Purely cosmetic and local to each machine; never affects gameplay."
			}));
			ModSettingsManager.AddOption((BaseOption)new StepSliderOption(BloodAmount, new StepSliderConfig
			{
				name = "Blood Amount",
				category = "Gore",
				description = "How many blood decals kills, landing gibs and bullets throw down. Scales only the count — sizes, corpse cutting and the hard caps are unchanged, so it can never run away. In multiplayer the host's value applies to everyone from the next stage.",
				min = 0.25f,
				max = 4f,
				increment = 0.25f
			}));
			object obj = <>O.<0>__Toggle;
			if (obj == null)
			{
				UnityAction val = TitlePickerUI.Toggle;
				<>O.<0>__Toggle = val;
				obj = (object)val;
			}
			ModSettingsManager.AddOption((BaseOption)new GenericButtonOption("Choose Title", "Loading Screen", "Pick which earned title your loading-screen card wears, right here in this panel. Earned titles are full brightness, locked ones are dimmed, the worn one is framed.", "Browse", (UnityAction)obj));
			object obj2 = <>O.<1>__ToggleBackgrounds;
			if (obj2 == null)
			{
				UnityAction val2 = TitlePickerUI.ToggleBackgrounds;
				<>O.<1>__ToggleBackgrounds = val2;
				obj2 = (object)val2;
			}
			ModSettingsManager.AddOption((BaseOption)new GenericButtonOption("Choose Card Background", "Loading Screen", "Pick your loading-screen calling card, right here in this panel: every country's flag and every pride flag is always available, pattern backgrounds unlock via the level lottery.", "Browse", (UnityAction)obj2));
			object obj3 = <>O.<2>__ToggleArcadeColors;
			if (obj3 == null)
			{
				UnityAction val3 = TitlePickerUI.ToggleArcadeColors;
				<>O.<2>__ToggleArcadeColors = val3;
				obj3 = (object)val3;
			}
			ModSettingsManager.AddOption((BaseOption)new GenericButtonOption("Choose Arcade Colors", "Loading Screen", "Pick up to three favorite colors for your loading-screen arcade commando, in order of preference. The arcade gives everyone the highest choice that's still free.", "Browse", (UnityAction)obj3));
			object obj4 = <>O.<3>__ToggleNames;
			if (obj4 == null)
			{
				UnityAction val4 = TitlePickerUI.ToggleNames;
				<>O.<3>__ToggleNames = val4;
				obj4 = (object)val4;
			}
			ModSettingsManager.AddOption((BaseOption)new GenericButtonOption("Choose Name Effect", "Loading Screen", "Pick which earned animated effect your loading-screen name wears. The terrarium pet digs these up as it grows; earned rows preview live.", "Browse", (UnityAction)obj4));
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(ArcadeEnabled, new CheckBoxConfig
			{
				name = "Arcade Minigames",
				category = "Loading Screen",
				description = "Minigames on the loading screen while the stage converts. Purely local UI — changes nothing about terrain or networking."
			}));
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(RevealSounds, new CheckBoxConfig
			{
				name = "Loading Screen Sounds",
				category = "Loading Screen",
				description = "Sound effects for the loading-screen prize reel, borrowed from the game's own UI soundbank."
			}));
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.Xerdi.ScorchedVoxels", "ScorchedVoxels", "0.20.72")]
	public class ScorchedVoxelsPlugin : BaseUnityPlugin
	{
		public const string Guid = "com.Xerdi.ScorchedVoxels";

		public const string ModName = "ScorchedVoxels";

		public const string Version = "0.20.72";

		internal static ManualLogSource Log;

		private void Awake()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			ModOptions.Bind(((BaseUnityPlugin)this).Config);
			if (ScorchedEarthIsActive())
			{
				Log.LogError((object)"ScorchedVoxels: ScorchedEarth is installed and enabled — ScorchedVoxels DISABLED itself (both mods carving the same explosions corrupts terrain). Disable one of the two.");
				return;
			}
			try
			{
				new Harmony("com.Xerdi.ScorchedVoxels").PatchAll(typeof(ScorchedVoxelsPlugin).Assembly);
			}
			catch (Exception arg)
			{
				Log.LogError((object)("ScorchedVoxels: Harmony PatchAll failed. Continuing with whatever patches applied " + $"so networking and lifecycle init still run: {arg}"));
			}
			NetworkingAPI.RegisterMessageType<CarveMessage>();
			NetworkingAPI.RegisterMessageType<GougeMessage>();
			NetworkingAPI.RegisterMessageType<GougeRequestMessage>();
			NetworkingAPI.RegisterMessageType<ClientConvertedMessage>();
			NetworkingAPI.RegisterMessageType<ConvertProgressMessage>();
			NetworkingAPI.RegisterMessageType<LoadingSyncMessage>();
			NetworkingAPI.RegisterMessageType<StageConfigMessage>();
			NetworkingAPI.RegisterMessageType<LifetimeBaseMessage>();
			NetworkingAPI.RegisterMessageType<UnlockRevealMessage>();
			NetworkingAPI.RegisterMessageType<LootReelMessage>();
			NetworkingAPI.RegisterMessageType<ArcadeSnapshotMessage>();
			NetworkingAPI.RegisterMessageType<WormsMatchMessage>();
			NetworkingAPI.RegisterMessageType<WormsShotRequestMessage>();
			NetworkingAPI.RegisterMessageType<WormsShotMessage>();
			NetworkingAPI.RegisterMessageType<RaceMatchMessage>();
			NetworkingAPI.RegisterMessageType<RaceSnapshotMessage>();
			NetworkingAPI.RegisterMessageType<GoreDeathMessage>();
			NetworkingAPI.RegisterMessageType<GoreHitMessage>();
			NetworkingAPI.RegisterMessageType<GoreWoundMessage>();
			NetworkingAPI.RegisterMessageType<GoreLiveBiteMessage>();
			NetworkingAPI.RegisterMessageType<TerrariumStateMessage>();
			NetworkingAPI.RegisterMessageType<TerrariumPetMessage>();
			GoreSystem.Init();
			Stage.onStageStartGlobal += OnStageStart;
			Run.onRunDestroyGlobal += delegate
			{
				UserLifetimeStats.OnRunEnd();
				TerrariumGame.OnRunEnd();
				VoxelTerrainManager.OnRunDestroy();
				CarveStats.ResetRun();
				TitleSystem.OnRunEnd();
			};
			if (Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions"))
			{
				try
				{
					ModOptions.SetupRiskOfOptions();
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("ScorchedVoxels: Risk of Options integration failed (menu skipped): " + ex.Message));
				}
			}
			Log.LogInfo((object)"ScorchedVoxels 0.20.72 loaded.");
		}

		private static bool ScorchedEarthIsActive()
		{
			if (!Chainloader.PluginInfos.TryGetValue("com.Xerdi.ScorchedEarth", out var value))
			{
				return false;
			}
			try
			{
				if ((((object)value.Instance)?.GetType().GetField("Enabled", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))?.GetValue(null) is ConfigEntry<bool> val)
				{
					return val.Value;
				}
			}
			catch
			{
			}
			return true;
		}

		private static void OnStageStart(Stage stage)
		{
			try
			{
				OverlapAttackFirePatch.OnStageStart();
				TerrariumSkins.OnStageStart();
				VoxelTerrainManager.OnStageStart(stage);
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Stage conversion failed: {arg}");
			}
		}

		private void Update()
		{
			MainThread.Pump();
			VoxelTerrainManager.Tick();
			try
			{
				TitlePickerUI.Tick();
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("picker tick", e);
			}
			GoreDebug.Tick();
		}
	}
	internal static class UiKit
	{
		internal class Label
		{
			public RectTransform Rect;

			private TMP_Text tmp;

			private Text legacy;

			private string txt = "";

			public TMP_Text Tmp => tmp;

			public string Text
			{
				get
				{
					return txt;
				}
				set
				{
					if (!(txt == value))
					{
						txt = value;
						if ((Object)(object)tmp != (Object)null)
						{
							tmp.text = value;
						}
						else if ((Object)(object)legacy != (Object)null)
						{
							legacy.text = value;
						}
					}
				}
			}

			public Color Color
			{
				set
				{
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)tmp != (Object)null)
					{
						((Graphic)tmp).color = value;
					}
					else if ((Object)(object)legacy != (Object)null)
					{
						((Graphic)legacy).color = value;
					}
				}
			}

			public void Italic()
			{
				//IL_0015: 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)
				if ((Object)(object)tmp != (Object)null)
				{
					TMP_Text obj = tmp;
					obj.fontStyle = (FontStyles)(obj.fontStyle | 2);
				}
				else if ((Object)(object)legacy != (Object)null)
				{
					legacy.fontStyle = (FontStyle)2;
				}
			}

			public void Bold()
			{
				//IL_0015: 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)
				if ((Object)(object)tmp != (Object)null)
				{
					TMP_Text obj = tmp;
					obj.fontStyle = (FontStyles)(obj.fontStyle | 1);
				}
				else if ((Object)(object)legacy != (Object)null)
				{
					legacy.fontStyle = (FontStyle)1;
				}
			}

			public void ClipSingleLine()
			{
				if ((Object)(object)tmp != (Object)null)
				{
					tmp.enableWordWrapping = false;
					tmp.overflowMode = (TextOverflowModes)1;
				}
				else if ((Object)(object)legacy != (Object)null)
				{
					legacy.horizontalOverflow = (HorizontalWrapMode)1;
					legacy.verticalOverflow = (VerticalWrapMode)0;
				}
			}

			public void WrapClipped()
			{
				if ((Object)(object)tmp != (Object)null)
				{
					tmp.enableWordWrapping = true;
					tmp.overflowMode = (TextOverflowModes)1;
				}
				else if ((Object)(object)legacy != (Object)null)
				{
					legacy.horizontalOverflow = (HorizontalWrapMode)0;
					legacy.verticalOverflow = (VerticalWrapMode)0;
				}
			}

			internal static Label Create(string name, Transform parent, float size, Color color, TextAnchor align)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_008c: 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_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: 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)
				GameObject val = new GameObject(name);
				val.transform.SetParent(parent, false);
				Label label = new Label();
				if (TmpReady())
				{
					HGTextMeshProUGUI val2 = val.AddComponent<HGTextMeshProUGUI>();
					((TMP_Text)val2).fontSize = size;
					((Graphic)val2).color = color;
					((TMP_Text)val2).alignment = MapAlign(align);
					((Graphic)val2).raycastTarget = false;
					((TMP_Text)val2).enableWordWrapping = false;
					((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
					label.tmp = (TMP_Text)(object)val2;
					label.Rect = ((TMP_Text)val2).rectTransform;
				}
				else
				{
					Text val3 = val.AddComponent<Text>();
					val3.font = LoadFont();
					val3.fontSize = Mathf.RoundToInt(size);
					((Graphic)val3).color = color;
					val3.alignment = align;
					((Graphic)val3).raycastTarget = false;
					val3.horizontalOverflow = (HorizontalWrapMode)1;
					val3.verticalOverflow = (VerticalWrapMode)1;
					label.legacy = val3;
					label.Rect = ((Graphic)val3).rectTransform;
				}
				return label;
			}

			private static TextAlignmentOptions MapAlign(TextAnchor a)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected I4, but got Unknown
				return (TextAlignmentOptions)((a - 1) switch
				{
					2 => 513, 
					4 => 516, 
					0 => 258, 
					6 => 1026, 
					_ => 514, 
				});
			}
		}

		internal class Btn
		{
			public GameObject Go;

			public RectTransform Rect;

			public Button Button;

			public Label Label;

			public Image Face;

			public bool Interactable
			{
				get
				{
					return ((Selectable)Button).interactable;
				}
				set
				{
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					if (((Selectable)Button).interactable != value)
					{
						((Selectable)Button).interactable = value;
						Label.Color = (value ? TextPale : TextDim);
					}
				}
			}

			public string Text
			{
				get
				{
					return Label.Text;
				}
				set
				{
					Label.Text = value;
				}
			}
		}

		public static readonly Color PanelSolid = new Color(0.043f, 0.051f, 0.075f, 1f);

		public static readonly Color PanelMid = new Color(0.098f, 0.11f, 0.145f, 1f);

		public static readonly Color Outline = new Color(0.55f, 0.58f, 0.62f, 0.35f);

		public static readonly Color OutlineBright = new Color(0.78f, 0.8f, 0.82f, 0.65f);

		public static readonly Color HeaderTan = new Color(0.79f, 0.72f, 0.54f, 1f);

		public static readonly Color TextPale = new Color(0.86f, 0.87f, 0.88f, 1f);

		public static readonly Color TextDim = new Color(0.56f, 0.57f, 0.6f, 1f);

		public static readonly Color Gold = new Color(1f, 0.83f, 0.35f, 1f);

		public static readonly Color AccentOrange = new Color(0.85f, 0.45f, 0.15f, 1f);

		public static readonly Color Green = new Color(0.35f, 0.75f, 0.3f, 1f);

		private static bool tmpUsable;

		private static bool tmpWarned;

		private static Font cachedFont;

		private static bool fontSearched;

		private static Sprite chamferFill;

		private static Sprite chamferOutline;

		private static Sprite gradientScrim;

		private const int ChSize = 48;

		private const int ChCorner = 10;

		private const int ChEdge = 2;

		public static string CubicSuffix { get; private set; } = "m³";

		private static bool TmpReady()
		{
			if (tmpUsable)
			{
				return true;
			}
			TMP_FontAsset defaultLanguageFont = HGTextMeshProUGUI.defaultLanguageFont;
			if ((Object)(object)defaultLanguageFont == (Object)null)
			{
				if (!tmpWarned)
				{
					tmpWarned = true;
					ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] game TMP font not ready — UI falls back to legacy text until it is");
				}
				return false;
			}
			tmpUsable = true;
			try
			{
				if (!defaultLanguageFont.HasCharacter('³', true, false))
				{
					CubicSuffix = "m3";
				}
			}
			catch
			{
				CubicSuffix = "m3";
			}
			ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] UI font: " + ((Object)defaultLanguageFont).name + " (cubic suffix '" + CubicSuffix + "')"));
			return true;
		}

		private static Font LoadFont()
		{
			if ((Object)(object)cachedFont != (Object)null || fontSearched)
			{
				return cachedFont;
			}
			fontSearched = true;
			string[] array = new string[2] { "Arial.ttf", "LegacyRuntime.ttf" };
			foreach (string text in array)
			{
				try
				{
					Font builtinResource = Resources.GetBuiltinResource<Font>(text);
					if ((Object)(object)builtinResource != (Object)null)
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] overlay font: builtin " + text));
						return cachedFont = builtinResource;
					}
				}
				catch
				{
				}
			}
			array = new string[3] { "Arial", "Segoe UI", "Verdana" };
			foreach (string text2 in array)
			{
				try
				{
					Font val = Font.CreateDynamicFontFromOSFont(text2, 24);
					if ((Object)(object)val != (Object)null)
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] overlay font: OS " + text2));
						return cachedFont = val;
					}
				}
				catch
				{
				}
			}
			try
			{
				Font[] array2 = Resources.FindObjectsOfTypeAll<Font>();
				foreach (Font val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] overlay font: borrowed '" + ((Object)val2).name + "'"));
						return cachedFont = val2;
					}
				}
			}
			catch
			{
			}
			ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] no usable UI font found — overlay text disabled");
			return null;
		}

		public static Label CreateLabel(string name, Transform parent, float size, Color color, TextAnchor align)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return Label.Create(name, parent, size, color, align);
		}

		public static Sprite ChamferFill()
		{
			if ((Object)(object)chamferFill == (Object)null)
			{
				chamferFill = BuildChamfer(fill: true);
			}
			return chamferFill;
		}

		public static Sprite ChamferOutline()
		{
			if ((Object)(object)chamferOutline == (Object)null)
			{
				chamferOutline = BuildChamfer(fill: false);
			}
			return chamferOutline;
		}

		private static Sprite BuildChamfer(bool fill)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Texture2D val = new Texture2D(48, 48, (TextureFormat)5, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[2304];
			for (int i = 0; i < 48; i++)
			{
				for (int j = 0; j < 48; j++)
				{
					int num = 0;
					for (int k = 0; k < 3; k++)
					{
						for (int l = 0; l < 3; l++)
						{
							float x = (float)j + ((float)l + 0.5f) / 3f;
							float y = (float)i + ((float)k + 0.5f) / 3f;
							if (fill ? Inside(x, y) : Border(x, y))
							{
								num++;
							}
						}
					}
					array[i * 48 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)(num * 255 / 9));
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			Vector4 val2 = default(Vector4);
			((Vector4)(ref val2))..ctor(14f, 14f, 14f, 14f);
			return Sprite.Create(val, new Rect(0f, 0f, 48f, 48f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, val2);
			static bool Border(float num2, float num3)
			{
				if (!Inside(num2, num3))
				{
					return false;
				}
				if (Inside(num2 - 2f, num3) && Inside(num2 + 2f, num3) && Inside(num2, num3 - 2f) && Inside(num2, num3 + 2f) && Inside(num2 - 1.42f, num3 - 1.42f) && Inside(num2 + 1.42f, num3 + 1.42f) && Inside(num2 - 1.42f, num3 + 1.42f))
				{
					return !Inside(num2 + 1.42f, num3 - 1.42f);
				}
				return true;
			}
			static bool Inside(float num2, float num3)
			{
				if (num2 < 0f || num3 < 0f || num2 > 48f || num3 > 48f)
				{
					return false;
				}
				float num4 = Mathf.Min(num2, 48f - num2);
				float num5 = Mathf.Min(num3, 48f - num3);
				return num4 + num5 >= 10f;
			}
		}

		public static Sprite GradientScrim()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gradientScrim != (Object)null)
			{
				return gradientScrim;
			}
			Texture2D val = new Texture2D(1, 64, (TextureFormat)5, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[64];
			for (int i = 0; i < 64; i++)
			{
				float num = (float)i / 63f;
				float num2 = Mathf.Clamp01(1.15f - num * 1.35f);
				array[i] = new Color32((byte)0, (byte)0, (byte)0, (byte)(num2 * 255f));
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			gradientScrim = Sprite.Create(val, new Rect(0f, 0f, 1f, 64f), new Vector2(0.5f, 0.5f), 100f);
			return gradientScrim;
		}

		public static Image CreatePanel(string name, Transform parent, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Image obj = CreateImage(name, parent, color);
			obj.sprite = ChamferFill();
			obj.type = (Type)1;
			return obj;
		}

		public static Image CreateOutline(string name, Transform parent, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Image obj = CreateImage(name, parent, color);
			obj.sprite = ChamferOutline();
			obj.type = (Type)1;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		public static Image CreateImage(string name, Transform parent, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = color;
			return obj;
		}

		public static void Stretch(RectTransform rt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}

		public static RawImage CreateMaskedCard(string name, Image face, Texture texture)
		{
			//IL_0012: 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)
			((Component)face).gameObject.AddComponent<Mask>().showMaskGraphic = true;
			GameObject val = new GameObject(name);
			val.transform.SetParent(((Component)face).transform, false);
			RawImage obj = val.AddComponent<RawImage>();
			Stretch(((Graphic)obj).rectTransform);
			((Graphic)obj).raycastTarget = false;
			obj.texture = texture;
			((Behaviour)obj).enabled = (Object)(object)texture != (Object)null;
			return obj;
		}

		public static Btn CreateButton(string name, Transform parent, Vector2 size, float fontSize, string text, UnityAction onClick)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0074: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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)
			Image val = CreatePanel(name, parent, Color.white);
			((Graphic)val).rectTransform.sizeDelta = size;
			Stretch(((Graphic)CreateOutline("edge", ((Component)val).transform, Outline)).rectTransform);
			Button val2 = ((Component)val).gameObject.AddComponent<Button>();
			((Selectable)val2).targetGraphic = (Graphic)(object)val;
			ColorBlock colors = ((Selectable)val2).colors;
			((ColorBlock)(ref colors)).normalColor = PanelMid;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.16f, 0.19f, 0.26f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.05f, 0.06f, 0.09f, 1f);
			((ColorBlock)(ref colors)).selectedColor = PanelMid;
			((ColorBlock)(ref colors)).disabledColor = new Color(PanelMid.r, PanelMid.g, PanelMid.b, 0.35f);
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)val2).colors = colors;
			if (onClick != null)
			{
				((UnityEvent)val2.onClick).AddListener(onClick);
			}
			Label label = CreateLabel("label", ((Component)val).transform, fontSize, TextPale, (TextAnchor)4);
			Stretch(label.Rect);
			label.ClipSingleLine();
			label.Text = text;
			return new Btn
			{
				Go = ((Component)val).gameObject,
				Rect = ((Graphic)val).rectTransform,
				Button = val2,
				Face = val,
				Label = label
			};
		}
	}
	internal sealed class UiMeter
	{
		public readonly Image Bg;

		public readonly Image Fill;

		private readonly float fillW;

		private readonly float fillH;

		private readonly float inset;

		private bool swept;

		public RectTransform Rect => ((Graphic)Bg).rectTransform;

		public UiMeter(string name, Transform parent, Vector2 size, Color bgColor, Color fillColor, float inset = 0f)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_0104: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			Bg = UiKit.CreateImage(name, parent, bgColor);
			((Graphic)Bg).rectTransform.sizeDelta = size;
			fillW = size.x - inset * 2f;
			fillH = ((inset > 0f) ? (size.y - inset * 2f) : 0f);
			this.inset = inset;
			Fill = UiKit.CreateImage("fill", ((Component)Bg).transform, fillColor);
			((Graphic)Fill).raycastTarget = false;
			((Graphic)Fill).rectTransform.anchorMin = new Vector2(0f, (inset > 0f) ? 0.5f : 0f);
			((Graphic)Fill).rectTransform.anchorMax = new Vector2(0f, (inset > 0f) ? 0.5f : 1f);
			((Graphic)Fill).rectTransform.pivot = new Vector2(0f, 0.5f);
			((Graphic)Fill).rectTransform.anchoredPosition = new Vector2(inset, 0f);
			((Graphic)Fill).rectTransform.sizeDelta = new Vector2(0f, fillH);
		}

		public void SetFrac(float frac)
		{
			//IL_0048: 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)
			if (swept)
			{
				swept = false;
				((Graphic)Fill).rectTransform.anchoredPosition = new Vector2(inset, 0f);
			}
			((Graphic)Fill).rectTransform.sizeDelta = new Vector2(fillW * frac, fillH);
		}

		public void SetSweep(float t, float segFrac)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			swept = true;
			float num = fillW * segFrac;
			((Graphic)Fill).rectTransform.anchoredPosition = new Vector2(inset + (fillW - num) * t, 0f);
			((Graphic)Fill).rectTransform.sizeDelta = new Vector2(num, fillH);
		}
	}
	internal sealed class UiTile
	{
		public readonly Image Face;

		public readonly Image Frame;

		public bool Selected
		{
			get
			{
				return ((Behaviour)Frame).enabled;
			}
			set
			{
				((Behaviour)Frame).enabled = value;
			}
		}

		public UiTile(string name, RectTransform content, Vector2 size, Vector2 pos, UnityAction onClick)
		{
			//IL_0009: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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)
			Face = UiKit.CreatePanel(name, (Transform)(object)content, UiKit.PanelMid);
			TopAnchor(((Graphic)Face).rectTransform);
			((Graphic)Face).rectTransform.sizeDelta = size;
			((Graphic)Face).rectTransform.anchoredPosition = pos;
			Frame = UiKit.CreateOutline("frame_" + name, (Transform)(object)content, UiKit.Gold);
			TopAnchor(((Graphic)Frame).rectTransform);
			((Graphic)Frame).rectTransform.sizeDelta = size + new Vector2(5f, 5f);
			((Graphic)Frame).rectTransform.anchoredPosition = pos;
			((Behaviour)Frame).enabled = false;
			((UnityEvent)((Component)Face).gameObject.AddComponent<Button>().onClick).AddListener(onClick);
		}

		private static void TopAnchor(RectTransform rt)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0.5f, 1f);
			rt.anchorMax = new Vector2(0.5f, 1f);
		}
	}
	internal sealed class UiWindow
	{
		public readonly GameObject Go;

		public readonly RectTransform Rect;

		public UiWindow(string name, Transform parent, Color back, Color edge)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Go = new GameObject(name);
			Go.transform.SetParent(parent, false);
			Rect = Go.AddComponent<RectTransform>();
			UiKit.Stretch(((Graphic)UiKit.CreatePanel("back", Go.transform, back)).rectTransform);
			UiKit.Stretch(((Graphic)UiKit.CreateOutline("edge", Go.transform, edge)).rectTransform);
		}

		public RectTransform AddMaskedContent()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("content");
			val.transform.SetParent(Go.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			UiKit.Stretch(obj);
			obj.offsetMin = new Vector2(2f, 2f);
			obj.offsetMax = new Vector2(-2f, -2f);
			val.AddComponent<RectMask2D>();
			return obj;
		}
	}
	internal static class BundleMeshCore
	{
		internal sealed class MeshBlob
		{
			public string name;

			public int vertexCount;

			public int subMeshCount;

			public float[] positions;

			public float[] uv0;

			public float[] uv1;

			public byte[] colors;

			public int[][] subTris;
		}

		private sealed class TypeTree
		{
			public int classId;

			public Node[] nodes;
		}

		internal struct Node
		{
			public string type;

			public string name;

			public int level;

			public uint metaFlags;
		}

		private sealed class Reader
		{
			public readonly byte[] Data;

			public int Pos;

			public bool BigEndian;

			public Reader(byte[] data, bool bigEndian)
			{
				Data = data;
				BigEndian = bigEndian;
			}

			public void Skip(int n)
			{
				Pos += n;
			}

			public void Align(int a)
			{
				int num = Pos % a;
				if (num != 0)
				{
					Pos += a - num;
				}
			}

			public byte U8()
			{
				return Data[Pos++];
			}

			public ushort U16()
			{
				ushort result = (BigEndian ? ((ushort)((Data[Pos] << 8) | Data[Pos + 1])) : ((ushort)(Data[Pos] | (Data[Pos + 1] << 8))));
				Pos += 2;
				return result;
			}

			public short I16()
			{
				return (short)U16();
			}

			public uint U32()
			{
				int result = (BigEndian ? ((Data[Pos] << 24) | (Data[Pos + 1] << 16) | (Data[Pos + 2] << 8) | Data[Pos + 3]) : (Data[Pos] | (Data[Pos + 1] << 8) | (Data[Pos + 2] << 16) | (Data[Pos + 3] << 24)));
				Pos += 4;
				return (uint)result;
			}

			public int I32()
			{
				return (int)U32();
			}

			public ulong U64()
			{
				ulong num;
				ulong num2;
				if (BigEndian)
				{
					num = U32();
					num2 = U32();
				}
				else
				{
					num2 = U32();
					num = U32();
				}
				return (num << 32) | num2;
			}

			public float F32()
			{
				if (!BigEndian)
				{
					float result = BitConverter.ToSingle(Data, Pos);
					Pos += 4;
					return result;
				}
				byte[] value = new byte[4]
				{
					Data[Pos + 3],
					Data[Pos + 2],
					Data[Pos + 1],
					Data[Pos]
				};
				Pos += 4;
				return BitConverter.ToSingle(value, 0);
			}

			public double F64()
			{
				if (!BigEndian)
				{
					double result = BitConverter.ToDouble(Data, Pos);
					Pos += 8;
					return result;
				}
				byte[] array = new byte[8];
				for (int i = 0; i < 8; i++)
				{
					array[i] = Data[Pos + 7 - i];
				}
				Pos += 8;
				return BitConverter.ToDouble(array, 0);
			}

			public string CString()
			{
				int num = Array.IndexOf(Data, (byte)0, Pos);
				string result = Encoding.UTF8.GetString(Data, Pos, num - Pos);
				Pos = num + 1;
				return result;
			}
		}

		public static Action<string> Debug = null;

		private static readonly byte[] CommonStrings = Encoding.UTF8.GetBytes("AABB\0AnimationClip\0AnimationCurve\0AnimationState\0Array\0Base\0BitField\0bitset\0bool\0char\0ColorRGBA\0Component\0data\0deque\0double\0dynamic_array\0FastPropertyName\0first\0float\0Font\0GameObject\0Generic Mono\0GradientNEW\0GUID\0GUIStyle\0int\0list\0long long\0map\0Matrix4x4f\0MdFour\0MonoBehaviour\0MonoScript\0m_ByteSize\0m_Curve\0m_EditorClassIdentifier\0m_EditorHideFlags\0m_Enabled\0m_ExtensionPtr\0m_GameObject\0m_Index\0m_IsArray\0m_IsStatic\0m_MetaFlag\0m_Name\0m_ObjectHideFlags\0m_PrefabInternal\0m_PrefabParentObject\0m_Script\0m_StaticEditorFlags\0m_Type\0m_Version\0Object\0pair\0PPtr<Component>\0PPtr<GameObject>\0PPtr<Material>\0PPtr<MonoBehaviour>\0PPtr<MonoScript>\0PPtr<Object>\0PPtr<Prefab>\0PPtr<Sprite>\0PPtr<TextAsset>\0PPtr<Texture>\0PPtr<Texture2D>\0PPtr<Transform>\0Prefab\0Quaternionf\0Rectf\0RectInt\0RectOffset\0second\0set\0short\0size\0SInt16\0SInt32\0SInt64\0SInt8\0staticvector\0string\0TextAsset\0TextMesh\0Texture\0Texture2D\0Transform\0TypelessData\0UInt16\0UInt32\0UInt64\0UInt8\0unsigned int\0unsigned long long\0unsigned short\0vector\0Vector2f\0Vector3f\0Vector4f\0m_ScriptingClassIdentifier\0Gradient\0Type*\0int2_storage\0int3_storage\0BoundsInt\0m_CorrespondingSourceObject\0m_PrefabInstance\0m_PrefabAsset\0FileSize\0Hash128\0RenderingLayerMask\0fixed_array\0EntityId\0");

		public static List<MeshBlob> LoadMeshes(string bundlePath, HashSet<string> names)
		{
			List<MeshBlob> result = new List<MeshBlob>();
			Dictionary<string, byte[]> dictionary = ReadBundleNodes(File.ReadAllBytes(bundlePath));
			Dictionary<string, byte[]> dictionary2 = new Dictionary<string, byte[]>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, byte[]> item in dictionary)
			{
				if (item.Key.EndsWith(".resS", StringComparison.OrdinalIgnoreCase) || item.Key.EndsWith(".resource", StringComparison.OrdinalIgnoreCase))
				{
					dictionary2[item.Key] = item.Value;
				}
			}
			foreach (KeyValuePair<string, byte[]> item2 in dictionary)
			{
				Debug?.Invoke($"node '{item2.Key}' {item2.Value.Length} bytes");
				if (!dictionary2.ContainsKey(item2.Key) && item2.Value.Length >= 48)
				{
					try
					{
						ReadSerializedMeshes(item2.Value, names, dictionary2, result);
					}
					catch (NotSupportedException)
					{
						throw;
					}
					catch (Exception ex2)
					{
						Debug?.Invoke("  node '" + item2.Key + "' not read as serialized file: " + ex2.GetType().Name + ": " + ex2.Message);
					}
				}
			}
			return result;
		}

		private static Dictionary<string, byte[]> ReadBundleNodes(byte[] file)
		{
			Reader reader = new Reader(file, bigEndian: true);
			string text = reader.CString();
			if (text != "UnityFS")
			{
				throw new NotSupportedException("bundle signature '" + text + "'");
			}
			uint num = reader.U32();
			if (num < 6 || num > 8)
			{
				throw new NotSupportedException($"bundle format {num}");
			}
			reader.CString();
			reader.CString();
			reader.U64();
			int num2 = (int)reader.U32();
			int uncompressedSize = (int)reader.U32();
			uint num3 = reader.U32();
			uint compression = num3 & 0x3F;
			if (num >= 7)
			{
				reader.Align(16);
			}
			byte[] data;
			if ((num3 & 0x80) != 0)
			{
				data = Decompress(file, file.Length - num2, num2, uncompressedSize, compression);
			}
			else
			{
				data = Decompress(file, reader.Pos, num2, uncompressedSize, compression);
				reader.Pos += num2;
			}
			if ((num3 & 0x200) != 0)
			{
				reader.Align(16);
			}
			Reader reader2 = new Reader(data, bigEndian: true);
			reader2.Skip(16);
			int num4 = (int)reader2.U32();
			int[] array = new int[num4];
			int[] array2 = new int[num4];
			ushort[] array3 = new ushort[num4];
			long num5 = 0L;
			for (int i = 0; i < num4; i++)
			{
				array[i] = (int)reader2.U32();
				array2[i] = (int)reader2.U32();
				array3[i] = reader2.U16();
				num5 += array[i];
			}
			int num6 = (int)reader2.U32();
			long[] array4 = new long[num6];
			long[] array5 = new long[num6];
			string[] array6 = new string[num6];
			for (int j = 0; j < num6; j++)
			{
				array4[j] = (long)reader2.U64();
				array5[j] = (long)reader2.U64();
				reader2.U32();
				array6[j] = reader2.CString();
			}
			byte[] array7 = new byte[num5];
			int num7 = reader.Pos;
			int num8 = 0;
			for (int k = 0; k < num4; k++)
			{
				uint num9 = (uint)(array3[k] & 0x3F);
				switch (num9)
				{
				case 0u:
					Buffer.BlockCopy(file, num7, array7, num8, array2[k]);
					break;
				case 2u:
				case 3u:
					Lz4Decompress(file, num7, array2[k], array7, num8, array[k]);
					break;
				default:
					throw new NotSupportedException($"block compression {num9}");
				}
				num7 += array2[k];
				num8 += array[k];
			}
			Dictionary<string, byte[]> dictionary = new Dictionary<string, byte[]>(StringComparer.OrdinalIgnoreCase);
			for (int l = 0; l < num6; l++)
			{
				byte[] array8 = new byte[array5[l]];
				Buffer.BlockCopy(array7, (int)array4[l], array8, 0, (int)array5[l]);
				dictionary[array6[l]] = array8;
			}
			return dictionary;
		}

		private static byte[] Decompress(byte[] src, int offset, int compressedSize, int uncompressedSize, uint compression)
		{
			byte[] array = new byte[uncompressedSize];
			switch (compression)
			{
			case 0u:
				Buffer.BlockCopy(src, offset, array, 0, uncompressedSize);
				break;
			case 2u:
			case 3u:
				Lz4Decompress(src, offset, compressedSize, array, 0, uncompressedSize);
				break;
			default:
				throw new NotSupportedException($"bundle compression {compression}");
			}
			return array;
		}

		private static void Lz4Decompress(byte[] src, int srcOff, int srcLen, byte[] dst, int dstOff, int dstLen)
		{
			int num = srcOff;
			int num2 = srcOff + srcLen;
			int num3 = dstOff;
			int num4 = dstOff + dstLen;
			while (num < num2 && num3 < num4)
			{
				byte b = src[num++];
				int num5 = b >> 4;
				if (num5 == 15)
				{
					byte b2;
					do
					{
						b2 = src[num++];
						num5 += b2;
					}
					while (b2 == byte.MaxValue);
				}
				Buffer.BlockCopy(src, num, dst, num3, num5);
				num += num5;
				num3 += num5;
				if (num >= num2)
				{
					break;
				}
				int num6 = src[num] | (src[num + 1] << 8);
				num += 2;
				int num7 = b & 0xF;
				if (num7 == 15)
				{
					byte b3;
					do
					{
						b3 = src[num++];
						num7 += b3;
					}
					while (b3 == byte.MaxValue);
				}
				num7 += 4;
				int num8 = num3 - num6;
				for (int i = 0; i < num7; i++)
				{
					dst[num3 + i] = dst[num8 + i];
				}
				num3 += num7;
			}
			if (num3 != num4)
			{
				throw new InvalidDataException($"LZ4 short output ({num3 - dstOff}/{dstLen})");
			}
		}

		private static void ReadSerializedMeshes(byte[] file, HashSet<string> names, Dictionary<string, byte[]> resources, List<MeshBlob> result)
		{
			Reader reader = new Reader(file, bigEndian: true);
			reader.U32();
			uint num = reader.U32();
			uint num2 = reader.U32();
			long num3 = reader.U32();
			if (num2 < 17 || num2 > 22)
			{
				throw new InvalidDataException($"serialized version {num2}");
			}
			if (num != 0 && num2 < 22 && num != file.Length)
			{
				throw new InvalidDataException("file size mismatch");
			}
			byte b = reader.U8();
			reader.Skip(3);
			if (num2 >= 22)
			{
				reader.U32();
				ulong num4 = reader.U64();
				num3 = (long)reader.U64();
				reader.U64();
				if (num4 != (ulong)file.Length)
				{
					throw new InvalidDataException("file size mismatch");
				}
			}
			reader.BigEndian = b != 0;
			reader.CString();
			reader.U32();
			if (reader.U8() == 0)
			{
				throw new NotSupportedException("type trees stripped from bundle");
			}
			int num5 = (int)reader.U32();
			TypeTree[] array = new TypeTree[num5];
			for (int i = 0; i < num5; i++)
			{
				array[i] = ReadType(reader, num2);
			}
			int num6 = reader.I32();
			Debug?.Invoke($"  serialized v{num2} types={num5} objects={num6}");
			int num7 = 0;
			for (int j = 0; j < num6; j++)
			{
				reader.Align(4);
				reader.U64();
				long num8 = (long)((num2 >= 22) ? reader.U64() : reader.U32());
				reader.U32();
				int num9 = reader.I32();
				TypeTree typeTree = array[num9];
				if (typeTree.classId != 43)
				{
					continue;
				}
				num7++;
				Reader reader2 = new Reader(file, reader.BigEndian)
				{
					Pos = (int)(num3 + num8)
				};
				int num10 = (int)reader2.U32();
				if (num10 < 0 || num10 > 512)
				{
					continue;
				}
				string text = Encoding.UTF8.GetString(file, reader2.Pos, num10);
				Debug?.Invoke("    mesh object '" + text + "'");
				if (names.Contains(text))
				{
					reader2.Pos = (int)(num3 + num8);
					int nextSibling;
					MeshBlob meshBlob = DecodeMesh((Dictionary<string, object>)ReadValue(reader2, typeTree.nodes, 0, out nextSibling), resources);
					if (meshBlob != null)
					{
						result.Add(meshBlob);
					}
				}
			}
		}

		private static TypeTree ReadType(Reader r, uint version)
		{
			TypeTree typeTree = new TypeTree
			{
				classId = r.I32()
			};
			r.U8();
			r.I16();
			if (typeTree.classId == 114)
			{
				r.Skip(16);
			}
			r.Skip(16);
			int num = (int)r.U32();
			int num2 = (int)r.U32();
			int num3 = ((version >= 19) ? 32 : 24);
			int num4 = r.Pos + num * num3;
			Node[] array = new Node[num];
			for (int i = 0; i < num; i++)
			{
				r.U16();
				int level = r.U8();
				r.U8();
				uint offset = r.U32();
				uint offset2 = r.U32();
				r.I32();
				r.I32();
				uint metaFlags = r.U32();
				if (version >= 19)
				{
					r.U64();
				}
				array[i] = new Node
				{
					type = ResolveString(r.Data, num4, num2, offset),
					name = ResolveString(r.Data, num4, num2, offset2),
					level = level,
					metaFlags = metaFlags
				};
			}
			r.Pos = num4 + num2;
			if (version >= 21)
			{
				int num5 = (int)r.U32();
				r.Skip(num5 * 4);
			}
			typeTree.nodes = array;
			return typeTree;
		}

		private static string ResolveString(byte[] data, int tableStart, int tableSize, uint offset)
		{
			if ((offset & 0x80000000u) != 0)
			{
				int num = (int)(offset & 0x7FFFFFFF);
				if (num >= CommonStrings.Length)
				{
					return num.ToString();
				}
				int num2 = Array.IndexOf(CommonStrings, (byte)0, num);
				return Encoding.UTF8.GetString(CommonStrings, num, num2 - num);
			}
			int num3 = tableStart + (int)offset;
			int num4 = Array.IndexOf(data, (byte)0, num3, tableSize - (int)offset);
			return Encoding.UTF8.GetString(data, num3, num4 - num3);
		}

		private static object ReadValue(Reader r, Node[] nodes, int i, out int nextSibling)
		{
			Node node = nodes[i];
			int j;
			for (j = i + 1; j < nodes.Length && nodes[j].level > node.level; j++)
			{
			}
			nextSibling = j;
			object result;
			switch (node.type)
			{
			case "bool":
				result = r.U8() != 0;
				break;
			case "SInt8":
				result = (sbyte)r.U8();
				break;
			case "char":
			case "UInt8":
				result = r.U8();
				break;
			case "short":
			case "SInt16":
				result = r.I16();
				break;
			case "UInt16":
			case "unsigned short":
				result = r.U16();
				break;
			case "SInt32":
			case "int":
				result = r.I32();
				break;
			case "Type*":
			case "UInt32":
			case "unsigned int":
				result = r.U32();
				break;
			case "SInt64":
			case "long long":
				result = (long)r.U64();
				break;
			case "UInt64":
			case "unsigned long long":
			case "FileSize":
				result = r.U64();
				break;
			case "float":
				result = r.F32();
				break;
			case "double":
				result = r.F64();
				break;
			case "string":
			{
				int num5 = (int)r.U32();
				result = Encoding.UTF8.GetString(r.Data, r.Pos, num5);
				r.Skip(num5);
				r.Align(4);
				break;
			}
			case "TypelessData":
			{
				int num6 = (int)r.U32();
				byte[] array2 = new byte[num6];
				Buffer.BlockCopy(r.Data, r.Pos, array2, 0, num6);
				r.Skip(num6);
				result = array2;
				break;
			}
			default:
				if (i + 1 < j && nodes[i + 1].type == "Array")
				{
					int num = i + 1;
					int num2 = num + 1 + 1;
					int num3 = r.I32();
					if (nodes[num2].type == "UInt8" || nodes[num2].type == "char")
					{
						byte[] array = new byte[num3];
						Buffer.BlockCopy(r.Data, r.Pos, array, 0, num3);
						r.Skip(num3);
						result = array;
					}
					else
					{
						List<object> list = new List<object>(num3);
						for (int k = 0; k < num3; k++)
						{
							list.Add(ReadValue(r, nodes, num2, out var _));
						}
						result = list;
					}
					if ((nodes[num].metaFlags & 0x4000) != 0)
					{
						r.Align(4);
					}
				}
				else
				{
					Dictionary<string, object> dictionary = new Dictionary<string, object>();
					int num4 = i + 1;
					while (num4 < j)
					{
						dictionary[nodes[num4].name] = ReadValue(r, nodes, num4, out var nextSibling3);
						num4 = nextSibling3;
					}
					result = dictionary;
				}
				break;
			}
			if ((node.metaFlags & 0x4000) != 0)
			{
				r.Align(4);
			}
			return result;
		}

		private static MeshBlob DecodeMesh(Dictionary<string, object> m, Dictionary<string, byte[]> resources)
		{
			if (Convert.ToByte(m["m_MeshCompression"]) != 0)
			{
				throw new NotSupportedException("compressed mesh data");
			}
			Dictionary<string, object> obj = (Dictionary<string, object>)m["m_VertexData"];
			int num = Convert.ToInt32(obj["m_VertexCount"]);
			List<object> list = (List<object>)obj["m_Channels"];
			byte[] array = (byte[])obj["m_DataSize"];
			if ((array == null || array.Length == 0) && m.TryGetValue("m_StreamData", out var value))
			{
				Dictionary<string, object> obj2 = (Dictionary<string, object>)value;
				long num2 = Convert.ToInt64(obj2["offset"]);
				int num3 = Convert.ToInt32(obj2["size"]);
				string text = (string)obj2["path"];
				if (num3 > 0)
				{
					string text2 = text.Substring(text.LastIndexOf('/') + 1);
					byte[] array2 = null;
					foreach (KeyValuePair<string, byte[]> resource in resources)
					{
						if (resource.Key.EndsWith(text2, StringComparison.OrdinalIgnoreCase))
						{
							array2 = resource.Value;
							break;
						}
					}
					if (array2 == null)
					{
						throw new InvalidDataException("resource '" + text2 + "' not in bundle");
					}
					array = new byte[num3];
					Buffer.BlockCopy(array2, (int)num2, array, 0, num3);
				}
			}
			if (array == null || array.Length == 0)
			{
				throw new InvalidDataException("no vertex data");
			}
			int num4 = 0;
			(int, int, int, int)[] array3 = new(int, int, int, int)[list.Count];
			for (int i = 0; i < list.Count; i++)
			{
				Dictionary<string, object> dictionary = (Dictionary<string, object>)list[i];
				array3[i] = (Convert.ToInt32(dictionary["stream"]), Convert.ToInt32(dictionary["offset"]), Convert.ToInt32(dictionary["format"]), Convert.ToInt32(dictionary["dimension"]) & 0xF);
				if (array3[i].Item4 > 0 && array3[i].Item1 + 1 > num4)
				{
					num4 = array3[i].Item1 + 1;
				}
			}
			int[] array4 = new int[num4];
			for (int j = 0; j < array3.Length; j++)
			{
				if (array3[j].Item4 > 0)
				{
					int num5 = array3[j].Item2 + array3[j].Item4 * SerializedFormatSize(array3[j].Item3);
					if (num5 > array4[array3[j].Item1])
					{
						array4[array3[j].Item1] = num5;
					}
				}
			}
			int[] array5 = new int[num4];
			int num6 = 0;
			for (int k = 0; k < num4; k++)
			{
				array5[k] = num6;
				num6 += num * array4[k];
				num6 = (num6 + 15) & -16;
			}
			MeshBlob meshBlob = new MeshBlob
			{
				vertexCount = num,
				name = (string)m["m_Name"]
			};
			meshBlob.positions = DecodeChannel(array, array3, array4, array5, 0, num, 3);
			if (array3.Length > 4 && array3[4].Item4 >= 2)
			{
				meshBlob.uv0 = DecodeChannel(array, array3, array4, array5, 4, num, 2);
			}
			if (array3.Length > 5 && array3[5].Item4 >= 2)
			{
				meshBlob.uv1 = DecodeChannel(array, array3, array4, array5, 5, num, 2);
			}
			if (array3.Length > 3 && array3[3].Item4 >= 4)
			{
				float[] array6 = DecodeChannel(array, array3, array4, array5, 3, num, 4);
				if (array6 != null)
				{
					meshBlob.colors = new byte[num * 4];
					for (int l = 0; l < num * 4; l++)
					{
						meshBlob.colors[l] = (byte)Math.Max(0, Math.Min(255, (int)Math.Round(array6[l] * 255f)));
					}
				}
			}
			if (meshBlob.positions == null)
			{
				throw new InvalidDataException("no position channel");
			}
			byte[] value2 = (byte[])m["m_IndexBuffer"];
			bool flag = Convert.ToInt32(m["m_IndexFormat"]) == 0;
			List<object> list2 = (List<object>)m["m_SubMeshes"];
			meshBlob.subMeshCount = list2.Count;
			meshBlob.subTris = new int[list2.Count][];
			for (int n = 0; n < list2.Count; n++)
			{
				Dictionary<string, object> obj3 = (Dictionary<string, object>)list2[n];
				int num7 = Convert.ToInt32(obj3["topology"]);
				if (num7 != 0)
				{
					throw new NotSupportedException($"submesh topology {num7}");
				}
				long num8 = Convert.ToInt64(obj3["firstByte"]);
				int num9 = Convert.ToInt32(obj3["indexCount"]);
				object value3;
				int num10 = (obj3.TryGetValue("baseVertex", out value3) ? Convert.ToInt32(value3) : 0);
				int[] array7 = new int[num9];
				for (int num11 = 0; num11 < num9; num11++)
				{
					int num12 = (int)(flag ? BitConverter.ToUInt16(value2, (int)num8 + num11 * 2) : BitConverter.ToUInt32(value2, (int)num8 + num11 * 4));
					array7[num11] = num12 + num10;
				}
				meshBlob.subTris[n] = array7;
			}
			return meshBlob;
		}

		private static float[] DecodeChannel(byte[] data, (int stream, int offset, int format, int dim)[] chan, int[] strides, int[] streamOffsets, int channelIndex, int vertexCount, int comps)
		{
			if (channelIndex >= chan.Length)
			{
				return null;
			}
			(int, int, int, int) tuple = chan[channelIndex];
			if (tuple.Item4 == 0)
			{
				return null;
			}
			int num = strides[tuple.Item1];
			int num2 = streamOffsets[tuple.Item1] + tuple.Item2;
			int num3 = SerializedFormatSize(tuple.Item3);
			float[] array = new float[vertexCount * comps];
			for (int i = 0; i < vertexCount; i++)
			{
				int num4 = num2 + i * num;
				for (int j = 0; j < comps; j++)
				{
					array[i * comps + j] = SerializedComponent(data, num4 + j * num3, tuple.Item3);
				}
			}
			return array;
		}

		private static int SerializedFormatSize(int fmt)
		{
			switch (fmt)
			{
			case 0:
				return 4;
			case 1:
			case 4:
			case 5:
				return 2;
			case 2:
			case 3:
				return 1;
			default:
				throw new NotSupportedException($"vertex format {fmt}");
			}
		}

		private static float SerializedComponent(byte[] data, int off, int fmt)
		{
			return fmt switch
			{
				0 => BitConverter.ToSingle(data, off), 
				1 => HalfToFloat(BitConverter.ToUInt16(data, off)), 
				2 => (float)(int)data[off] / 255f, 
				3 => Math.Max((float)(sbyte)data[off] / 127f, -1f), 
				4 => (float)(int)BitConverter.ToUInt16(data, off) / 65535f, 
				5 => Math.Max((float)(short)BitConverter.ToUInt16(data, off) / 32767f, -1f), 
				_ => throw new NotSupportedException($"vertex format {fmt}"), 
			};
		}

		private static float HalfToFloat(ushort h)
		{
			int num = (h >> 15) & 1;
			int num2 = (h >> 10) & 0x1F;
			int num3 = h & 0x3FF;
			float num4 = num2 switch
			{
				0 => (float)num3 * 0.0009765625f * 6.1035156E-05f, 
				31 => (num3 == 0) ? float.PositiveInfinity : float.NaN, 
				_ => (1f + (float)num3 * 0.0009765625f) * Pow2(num2 - 15), 
			};
			if (num != 1)
			{
				return num4;
			}
			return 0f - num4;
		}

		private static float Pow2(int e)
		{
			return (float)Math.Pow(2.0, e);
		}
	}
	[HarmonyPatch(typeof(BlastAttack), "Fire")]
	internal static class BlastAttackFirePatch
	{
		private static void Postfix(BlastAttack __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (ModOptions.Enabled.Value && NetworkServer.active && GoreSystem.Finite(__instance.position) && float.IsFinite(__instance.radius))
				{
					float radius = __instance.radius;
					if (!(radius < ModOptions.MinBlastRadius.Value))
					{
						float num = Mathf.Clamp(radius * ModOptions.RadiusMultiplier.Value, 0.9f, ModOptions.MaxCarveRadius.Value);
						VoxelTerrainManager.RequestCarve(__instance.position, num, ResolveAttackerUserId(__instance.attacker));
						NetMessageExtensions.Send((INetMessage)(object)new CarveMessage(__instance.position, num), (NetworkDestination)1);
					}
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogError((object)$"OnBlast failed: {arg}");
			}
		}

		internal static uint ResolveAttackerUserId(GameObject attacker)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)attacker == (Object)null)
			{
				return 0u;
			}
			CharacterBody component = attacker.GetComponent<CharacterBody>();
			CharacterMaster val = (((Object)(object)component != (Object)null) ? component.master : null);
			for (int i = 0; i < 4; i++)
			{
				if (!((Object)(object)val != (Object)null))
				{
					break;
				}
				if ((Object)(object)val.minionOwnership == (Object)null)
				{
					break;
				}
				if ((Object)(object)val.minionOwnership.ownerMaster == (Object)null)
				{
					break;
				}
				val = val.minionOwnership.ownerMaster;
			}
			PlayerCharacterMasterController val2 = (((Object)(object)val != (Object)null) ? val.playerCharacterMasterController : null);
			NetworkUser val3 = (((Object)(object)val2 != (Object)null) ? val2.networkUser : null);
			if (!((Object)(object)val3 != (Object)null))
			{
				return 0u;
			}
			NetworkInstanceId netId = ((NetworkBehaviour)val3).netId;
			return ((NetworkInstanceId)(ref netId)).Value;
		}
	}
	[HarmonyPatch(typeof(OverlapAttack), "Fire")]
	internal static class OverlapAttackFirePatch
	{
		private static readonly Dictionary<GameObject, float> lastCut = new Dictionary<GameObject, float>();

		private const float CutWindow = 0.12f;

		private const float CutLift = 0.4f;

		private static void Postfix(OverlapAttack __instance)
		{
			//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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_011c: 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_012a: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: 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_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: 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)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!ModOptions.Enabled.Value || !ModOptions.MeleeCarving.Value)
				{
					return;
				}
				bool active = NetworkServer.active;
				if (!active && !NetworkClient.active)
				{
					return;
				}
				HitBoxGroup hitBoxGroup = __instance.hitBoxGroup;
				if ((Object)(object)hitBoxGroup == (Object)null || hitBoxGroup.hitBoxes == null)
				{
					return;
				}
				GameObject key = (((Object)(object)__instance.attacker != (Object)null) ? __instance.attacker : ((Component)hitBoxGroup).gameObject);
				if (lastCut.TryGetValue(key, out var value) && Time.fixedTime - value < 0.12f)
				{
					return;
				}
				HitBox[] hitBoxes = hitBoxGroup.hitBoxes;
				foreach (HitBox val in hitBoxes)
				{
					if ((Object)(object)val == (Object)null || !((Behaviour)val).isActiveAndEnabled || (Object)(object)((Component)val).transform == (Object)null)
					{
						continue;
					}
					Transform transform = ((Component)val).transform;
					Vector3 lossyScale = transform.lossyScale;
					Vector3 val2 = new Vector3(Mathf.Abs(lossyScale.x), Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)) * 0.5f;
					if (Mathf.Max(val2.x, Mathf.Max(val2.y, val2.z)) < 0.2f)
					{
						continue;
					}
					Vector3 val3 = BladeHalf(val2);
					Vector3 val4 = transform.position + Vector3.up * 0.4f;
					Quaternion rotation = transform.rotation;
					LayerIndex world = LayerIndex.world;
					if (!Physics.CheckBox(val4, val3, rotation, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1))
					{
						continue;
					}
					if (Throttle(key))
					{
						if (ModOptions.VerboseLogging.Value)
						{
							ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] melee gouge at {val4} blade ({val3.x:F2},{val3.y:F2},{val3.z:F2})");
						}
						uint attackerUserId = BlastAttackFirePatch.ResolveAttackerUserId(__instance.attacker);
						if (active)
						{
							VoxelTerrainManager.RequestGouge(val4, transform.rotation, val3, attackerUserId);
							NetMessageExtensions.Send((INetMessage)(object)new GougeMessage(val4, transform.rotation, val3), (NetworkDestination)1);
						}
						else
						{
							NetMessageExtensions.Send((INetMessage)(object)new GougeRequestMessage(val4, transform.rotation, val3, attackerUserId), (NetworkDestination)2);
						}
					}
					break;
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogError((object)$"OnMeleeGouge failed: {arg}");
			}
		}

		private static Vector3 BladeHalf(Vector3 half)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Min(half.x, 4f);
			float num2 = Mathf.Min(half.y, 4f);
			float num3 = Mathf.Min(half.z, 4f);
			if (num <= num2 && num <= num3)
			{
				num = Mathf.Clamp(num, 0.2f, 0.3f);
			}
			else if (num2 <= num3)
			{
				num2 = Mathf.Clamp(num2, 0.2f, 0.3f);
			}
			else
			{
				num3 = Mathf.Clamp(num3, 0.2f, 0.3f);
			}
			return new Vector3(num, num2, num3);
		}

		private static bool Throttle(GameObject key)
		{
			float fixedTime = Time.fixedTime;
			if (lastCut.TryGetValue(key, out var value) && fixedTime - value < 0.12f)
			{
				return false;
			}
			if (lastCut.Count > 64)
			{
				lastCut.Clear();
			}
			lastCut[key] = fixedTime;
			return true;
		}

		internal static void OnStageStart()
		{
			lastCut.Clear();
		}
	}
	internal static class DebrisSystem
	{
		private class Piece
		{
			public GameObject go;

			public Transform tf;

			public MeshFilter mf;

			public MeshRenderer mr;

			public Vector3 vel;

			public Vector3 spinAxis;

			public float spinDeg;

			public float dieAt;

			public Vector3 baseScale;

			public float killY;

			public bool bounced;

			public bool slab;

			public bool fragment;
		}

		private const int VariantCount = 8;

		private const int SlabVariantCount = 4;

		private const float Gravity = 19f;

		private const float LifeMin = 3.4f;

		private const float LifeMax = 5f;

		private const float ShrinkTail = 0.9f;

		private const float RockVolumeK = 0.6f;

		private const float PieceMin = 0.14f;

		private const float PieceMax = 3f;

		private const float MinShatterDim = 0.4f;

		private static Mesh[] variants;

		private static Mesh[] slabVariants;

		private static readonly List<Piece> active = new List<Piece>();

		private static readonly Stack<Piece> pool = new Stack<Piece>();

		private static readonly float[] sizeScratch = new float[16];

		private static GameObject root;

		private static readonly Random rng = new Random(1584860190);

		public static void SpawnBurst(Vector3 center, float r, Material mat, float m3)
		{
			//IL_0168: 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_0179: 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_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: 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_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			if (!ModOptions.DebrisEnabled.Value || (Object)(object)mat == (Object)null)
			{
				return;
			}
			EnsureVariants();
			EnsureRoot();
			int value = ModOptions.DebrisMaxPieces.Value;
			int num = Mathf.Clamp(3 + Mathf.RoundToInt(Mathf.Pow(Mathf.Max(m3, 0.01f), 1f / 3f) * 1.5f), 3, sizeScratch.Length);
			float time = Time.time;
			float num2 = 0f;
			for (int i = 0; i < num; i++)
			{
				float num3 = ((i == 0 && num >= 5) ? 1f : Range(0.32f, 0.68f));
				sizeScratch[i] = num3;
				num2 += num3 * num3 * num3;
			}
			float num4 = Mathf.Pow(m3 / Mathf.Max(0.6f * num2, 0.0001f), 1f / 3f);
			float num5 = float.MaxValue;
			float num6 = 0f;
			for (int j = 0; j < num; j++)
			{
				float num7 = Mathf.Clamp(sizeScratch[j] * num4, 0.14f, 3f);
				sizeScratch[j] = num7;
				if (num7 < num5)
				{
					num5 = num7;
				}
				if (num7 > num6)
				{
					num6 = num7;
				}
			}
			for (int k = 0; k < num; k++)
			{
				if (active.Count >= value)
				{
					Recycle(0);
				}
				Piece piece = ((pool.Count > 0) ? pool.Pop() : CreatePiece());
				float num8 = sizeScratch[k];
				Vector3 val = RandomInUnitSphere() * (0.45f * r);
				Vector3 val2 = val + Vector3.up * (0.5f * r);
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				float num9 = Mathf.Clamp(r * 0.35f, 0.6f, 1.6f);
				piece.baseScale = Vector3.one * num8;
				float num10 = Mathf.InverseLerp(num5, num6, num8);
				float num11 = Mathf.Lerp(1.3f, 0.55f, num10);
				piece.vel = (normalized * (Range(3.5f, 8.5f) * num9) + Vector3.up * Range(1.5f, 3.5f)) * num11;
				val2 = RandomInUnitSphere();
				piece.spinAxis = ((Vector3)(ref val2)).normalized;
				if (((Vector3)(ref piece.spinAxis)).sqrMagnitude < 0.01f)
				{
					piece.spinAxis = Vector3.up;
				}
				piece.spinDeg = Range(90f, 420f) * Mathf.Lerp(1.2f, 0.6f, num10);
				piece.dieAt = time + Range(3.4f, 5f);
				piece.killY = center.y - 250f;
				piece.bounced = false;
				piece.slab = false;
				piece.fragment = false;
				piece.tf.position = center + val;
				piece.tf.rotation = Quaternion.Euler(Range(0f, 360f), Range(0f, 360f), Range(0f, 360f));
				piece.tf.localScale = piece.baseScale;
				piece.mf.sharedMesh = variants[rng.Next(8)];
				((Renderer)piece.mr).sharedMaterial = mat;
				piece.go.SetActive(true);
				active.Add(piece);
			}
		}

		public static void SpawnSlab(Vector3 c, Vector3 ax, Vector3 ay, Vector3 az, Vector3 half, Material mat, float m3)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_002e: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00a6: 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)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			if (ModOptions.DebrisEnabled.Value && !((Object)(object)mat == (Object)null))
			{
				EnsureVariants();
				EnsureRoot();
				Vector3 val = half * 2f;
				float num = val.x * val.y * val.z;
				float num2 = Mathf.Sqrt(Mathf.Clamp01(m3 / Mathf.Max(num, 0.0001f)));
				if (val.x <= val.y && val.x <= val.z)
				{
					val.y *= num2;
					val.z *= num2;
				}
				else if (val.y <= val.x && val.y <= val.z)
				{
					val.x *= num2;
					val.z *= num2;
				}
				else
				{
					val.x *= num2;
					val.y *= num2;
				}
				if (active.Count >= ModOptions.DebrisMaxPieces.Value)
				{
					Recycle(0);
				}
				Piece piece = ((pool.Count > 0) ? pool.Pop() : CreatePiece());
				float time = Time.time;
				piece.baseScale = val;
				piece.vel = Vector3.up * Range(1.2f, 2.2f) + RandomInUnitSphere() * 0.8f;
				Vector3 val2 = RandomInUnitSphere();
				piece.spinAxis = ((Vector3)(ref val2)).normalized;
				if (((Vector3)(ref piece.spinAxis)).sqrMagnitude < 0.01f)
				{
					piece.spinAxis = Vector3.up;
				}
				piece.spinDeg = Range(45f, 130f);
				piece.dieAt = time + Range(3.4f, 5f);
				piece.killY = c.y - 250f;
				piece.bounced = false;
				piece.slab = true;
				piece.fragment = false;
				piece.tf.position = c;
				piece.tf.rotation = Quaternion.LookRotation(az, ay);
				piece.tf.localScale = val;
				piece.mf.sharedMesh = slabVariants[rng.Next(4)];
				((Renderer)piece.mr).sharedMaterial = mat;
				piece.go.SetActive(true);
				active.Add(piece);
			}
		}

		private static void SpawnFragments(Vector3 at, Vector3 normal, Vector3 impactVel, Vector3 parentScale, bool slab, Material mat, float killY)
		{
			//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)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_010e: 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_0136: 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_014d: 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_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(parentScale.x, Mathf.Max(parentScale.y, parentScale.z));
			int num2 = Mathf.Clamp(2 + Mathf.RoundToInt(num * 1.5f), 3, 6);
			int num3 = ModOptions.DebrisMaxPieces.Value - active.Count;
			if (num2 > num3)
			{
				num2 = num3;
			}
			if (num2 < 2)
			{
				return;
			}
			float num4 = 0f;
			for (int i = 0; i < num2; i++)
			{
				float num5 = Range(0.35f, 0.75f);
				sizeScratch[i] = num5;
				num4 += num5 * num5 * num5;
			}
			float num6 = Mathf.Pow(num4, 1f / 3f);
			float time = Time.time;
			float num7 = Mathf.Max(((Vector3)(ref impactVel)).magnitude, 1.2f);
			for (int j = 0; j < num2; j++)
			{
				Piece piece = ((pool.Count > 0) ? pool.Pop() : CreatePiece());
				float num8 = sizeScratch[j] / num6;
				piece.baseScale = parentScale * num8;
				piece.slab = slab;
				piece.fragment = true;
				piece.vel = impactVel * Range(0.7f, 1.15f) + normal * (num7 * Range(0.25f, 0.6f)) + RandomInUnitSphere() * (num7 * 0.3f);
				Vector3 val = RandomInUnitSphere();
				piece.spinAxis = ((Vector3)(ref val)).normalized;
				if (((Vector3)(ref piece.spinAxis)).sqrMagnitude < 0.01f)
				{
					piece.spinAxis = Vector3.up;
				}
				piece.spinDeg = Range(180f, 540f);
				piece.dieAt = time + Range(3.4f, 5f);
				piece.killY = killY;
				piece.bounced = false;
				Vector3 val2 = Vector3.ProjectOnPlane(RandomInUnitSphere(), normal) * (0.25f * num);
				piece.tf.position = at + normal * Range(0.05f, 0.12f) + val2;
				piece.tf.rotation = Quaternion.Euler(Range(0f, 360f), Range(0f, 360f), Range(0f, 360f));
				piece.tf.localScale = piece.baseScale;
				piece.mf.sharedMesh = (slab ? slabVariants[rng.Next(4)] : variants[rng.Next(8)]);
				((Renderer)piece.mr).sharedMaterial = mat;
				piece.go.SetActive(true);
				active.Add(piece);
			}
		}

		private static void EnsureRoot()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)root != (Object)null))
			{
				root = new GameObject("ScorchedVoxelsDebris");
				pool.Clear();
				active.Clear();
			}
		}

		public static void Tick()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: 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_00de: 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_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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			if (active.Count == 0)
			{
				return;
			}
			float deltaTime = Time.deltaTime;
			if (deltaTime <= 0f)
			{
				return;
			}
			float time = Time.time;
			RaycastHit val3 = default(RaycastHit);
			for (int num = active.Count - 1; num >= 0; num--)
			{
				Piece piece = active[num];
				if ((Object)(object)piece.go == (Object)null)
				{
					active.RemoveAt(num);
					continue;
				}
				float num2 = piece.dieAt - time;
				Vector3 position = piece.tf.position;
				if (num2 <= 0f || position.y < piece.killY)
				{
					Recycle(num);
					continue;
				}
				piece.vel.y -= 19f * deltaTime;
				Vector3 val = piece.vel * deltaTime;
				if (!piece.bounced)
				{
					float magnitude = ((Vector3)(ref val)).magnitude;
					if (magnitude > 1E-05f)
					{
						Vector3 val2 = val / magnitude;
						float num3 = magnitude + 0.03f;
						LayerIndex world = LayerIndex.world;
						if (Physics.Raycast(position, val2, ref val3, num3, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1))
						{
							float num4 = Mathf.Max(piece.baseScale.x, Mathf.Max(piece.baseScale.y, piece.baseScale.z));
							if (!piece.fragment && num4 >= 0.4f && ModOptions.DebrisMaxPieces.Value - active.Count >= 2)
							{
								Vector3 impactVel = Vector3.Reflect(piece.vel, ((RaycastHit)(ref val3)).normal) * 0.45f;
								Vector3 baseScale = piece.baseScale;
								bool slab = piece.slab;
								Material sharedMaterial = ((Renderer)piece.mr).sharedMaterial;
								float killY = piece.killY;
								Recycle(num);
								SpawnFragments(((RaycastHit)(ref val3)).point, ((RaycastHit)(ref val3)).normal, impactVel, baseScale, slab, sharedMaterial, killY);
							}
							else
							{
								piece.bounced = true;
								piece.tf.position = ((RaycastHit)(ref val3)).point + ((RaycastHit)(ref val3)).normal * 0.05f;
								piece.vel = Vector3.Reflect(piece.vel, ((RaycastHit)(ref val3)).normal) * 0.45f;
								piece.spinDeg *= 1.4f;
							}
							continue;
						}
					}
				}
				piece.tf.position = position + val;
				piece.tf.Rotate(piece.spinAxis, piece.spinDeg * deltaTime, (Space)0);
				if (num2 < 0.9f)
				{
					piece.tf.localScale = piece.baseScale * (num2 / 0.9f);
				}
			}
		}

		public static void Reset()
		{
			if ((Object)(object)root != (Object)null)
			{
				Object.Destroy((Object)(object)root);
			}
			root = null;
			active.Clear();
			pool.Clear();
		}

		private static void Recycle(int index)
		{
			Piece piece = active[index];
			active.RemoveAt(index);
			if (!((Object)(object)piece.go == (Object)null))
			{
				piece.go.SetActive(false);
				pool.Push(piece);
			}
		}

		private static Piece CreatePiece()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("voxdebris");
			val.transform.SetParent(root.transform, false);
			Piece obj = new Piece
			{
				go = val,
				tf = val.transform,
				mf = val.AddComponent<MeshFilter>(),
				mr = val.AddComponent<MeshRenderer>()
			};
			((Renderer)obj.mr).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)obj.mr).receiveShadows = false;
			return obj;
		}

		private static void EnsureVariants()
		{
			if (variants == null)
			{
				variants = (Mesh[])(object)new Mesh[8];
				for (int i = 0; i < 8; i++)
				{
					variants[i] = BuildRock((uint)(i * 7919 + 101));
				}
				slabVariants = (Mesh[])(object)new Mesh[4];
				for (int j = 0; j < 4; j++)
				{
					slabVariants[j] = BuildSlab((uint)(j * 6151 + 47));
				}
			}
		}

		private static Mesh BuildSlab(uint seed)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//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_0076: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_010b: 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>(96);
			List<int> list2 = new List<int>(324);
			Vector3[] array = (Vector3[])(object)new Vector3[6]
			{
				Vector3.up,
				Vector3.down,
				Vector3.left,
				Vector3.right,
				Vector3.forward,
				Vector3.back
			};
			foreach (Vector3 val in array)
			{
				Vector3 val3;
				if (!(Mathf.Abs(val.y) > 0.5f))
				{
					Vector3 val2 = Vector3.Cross(Vector3.up, val);
					val3 = ((Vector3)(ref val2)).normalized;
				}
				else
				{
					val3 = Vector3.right;
				}
				Vector3 val4 = val3;
				Vector3 val5 = Vector3.Cross(val, val4);
				int count = list.Count;
				for (int j = 0; j <= 3; j++)
				{
					for (int k = 0; k <= 3; k++)
					{
						Vector3 val6 = val * 0.5f + val4 * ((float)k / 3f - 0.5f) + val5 * ((float)j / 3f - 0.5f);
						float num = VoxelVolume.ShapeNoise(val6 * 5.5f, seed);
						list.Add(val6 * (1f + 0.12f * num));
					}
				}
				for (int l = 0; l < 3; l++)
				{
					for (int m = 0; m < 3; m++)
					{
						int num2 = count + l * 4 + m;
						int num3 = num2 + 1;
						int num4 = num2 + 4;
						int num5 = num4 + 1;
						list2.AddRange(new int[6] { num2, num3, num5, num2, num5, num4 });
					}
				}
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[list2.Count];
			int[] array3 = new int[list2.Count];
			for (int n = 0; n < list2.Count; n++)
			{
				array2[n] = list[list2[n]];
				array3[n] = n;
			}
			Mesh val7 = new Mesh
			{
				name = $"voxdebris_slab{seed}",
				vertices = array2,
				triangles = array3
			};
			val7.RecalculateNormals();
			val7.RecalculateBounds();
			return val7;
		}

		private static Mesh BuildRock(uint seed)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			BuildIcosphere(out var verts, out var tris);
			for (int i = 0; i < verts.Count; i++)
			{
				Vector3 val = verts[i];
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				float num = VoxelVolume.ShapeNoise(normalized * 2.7f, seed);
				verts[i] = normalized * (1f + 0.38f * num) * 0.5f;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[tris.Count];
			int[] array2 = new int[tris.Count];
			for (int j = 0; j < tris.Count; j++)
			{
				array[j] = verts[tris[j]];
				array2[j] = j;
			}
			Mesh val2 = new Mesh
			{
				name = $"voxdebris_rock{seed}",
				vertices = array,
				triangles = array2
			};
			val2.RecalculateNormals();
			val2.RecalculateBounds();
			return val2;
		}

		private static void BuildIcosphere(out List<Vector3> verts, out List<int> tris)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			float num = (1f + Mathf.Sqrt(5f)) / 2f;
			verts = new List<Vector3>
			{
				new Vector3(-1f, num, 0f),
				new Vector3(1f, num, 0f),
				new Vector3(-1f, 0f - num, 0f),
				new Vector3(1f, 0f - num, 0f),
				new Vector3(0f, -1f, num),
				new Vector3(0f, 1f, num),
				new Vector3(0f, -1f, 0f - num),
				new Vector3(0f, 1f, 0f - num),
				new Vector3(num, 0f, -1f),
				new Vector3(num, 0f, 1f),
				new Vector3(0f - num, 0f, -1f),
				new Vector3(0f - num, 0f, 1f)
			};
			for (int i = 0; i < verts.Count; i++)
			{
				List<Vector3> obj = verts;
				int index = i;
				Vector3 val = verts[i];
				obj[index] = ((Vector3)(ref val)).normalized;
			}
			int[] array = new int[60]
			{
				0, 11, 5, 0, 5, 1, 0, 1, 7, 0,
				7, 10, 0, 10, 11, 1, 5, 9, 5, 11,
				4, 11, 10, 2, 10, 7, 6, 7, 1, 8,
				3, 9, 4, 3, 4, 2, 3, 2, 6, 3,
				6, 8, 3, 8, 9, 4, 9, 5, 2, 4,
				11, 6, 2, 10, 8, 6, 7, 9, 8, 1
			};
			tris = new List<int>(array.Length * 4);
			Dictionary<long, int> midCache = new Dictionary<long, int>();
			List<Vector3> vlist = verts;
			for (int j = 0; j < array.Length; j += 3)
			{
				int num2 = array[j];
				int num3 = array[j + 1];
				int num4 = array[j + 2];
				int num5 = Midpoint(num2, num3);
				int num6 = Midpoint(num3, num4);
				int num7 = Midpoint(num4, num2);
				tris.AddRange(new int[12]
				{
					num2, num5, num7, num3, num6, num5, num4, num7, num6, num5,
					num6, num7
				});
			}
			int Midpoint(int a, int b)
			{
				//IL_0036: 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_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				long key = ((a < b) ? (((long)a << 32) | (uint)b) : (((long)b << 32) | (uint)a));
				if (midCache.TryGetValue(key, out var value))
				{
					return value;
				}
				List<Vector3> list = vlist;
				Vector3 val2 = (vlist[a] + vlist[b]) * 0.5f;
				list.Add(((Vector3)(ref val2)).normalized);
				midCache[key] = vlist.Count - 1;
				return vlist.Count - 1;
			}
		}

		private static float Range(float min, float max)
		{
			return min + (float)rng.NextDouble() * (max - min);
		}

		private static Vector3 RandomInUnitSphere()
		{
			//IL_005f: 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)
			Vector3 result = default(Vector3);
			for (int i = 0; i < 8; i++)
			{
				((Vector3)(ref result))..ctor(Range(-1f, 1f), Range(-1f, 1f), Range(-1f, 1f));
				if (((Vector3)(ref result)).sqrMagnitude <= 1f)
				{
					return result;
				}
			}
			return new Vector3(0f, 0.5f, 0f);
		}
	}
	internal static class FarewellBlast
	{
		private struct Wave
		{
			public readonly float t;

			public readonly float ring;

			public readonly int count;

			public readonly float radius;

			public readonly float sink;

			public Wave(float t, float ring, int count, float radius, float sink)
			{
				this.t = t;
				this.ring = ring;
				this.count = count;
				this.radius = radius;
				this.sink = sink;
			}
		}

		private static readonly bool Active = false;

		private static readonly Wave[] Waves = new Wave[5]
		{
			new Wave(0.15f, 19f, 10, 5f, 1.5f),
			new Wave(0.7f, 13f, 8, 5.5f, 1.5f),
			new Wave(1.3f, 8f, 7, 6f, 2f),
			new Wave(2.1f, 0f, 1, 11f, 3f),
			new Wave(2.45f, 0f, 1, 8f, 9f)
		};

		private static bool running;

		private static float t0;

		private static Vector3 center;

		private static int nextWave;

		public static void Reset()
		{
			running = false;
		}

		public static void Trigger(Vector3 exitPos)
		{
			//IL_0024: 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)
			if (Active && NetworkServer.active && ModOptions.Enabled.Value && VoxelTerrainManager.LocalConversionDone)
			{
				center = exitPos;
				t0 = Time.time;
				nextWave = 0;
				running = true;
			}
		}

		public static void Tick()
		{
			if (!running)
			{
				return;
			}
			if (!VoxelTerrainManager.LocalConversionDone)
			{
				running = false;
				return;
			}
			float num = Time.time - t0;
			while (nextWave < Waves.Length && num >= Waves[nextWave].t)
			{
				Fire(Waves[nextWave++]);
			}
			if (nextWave >= Waves.Length)
			{
				running = false;
			}
		}

		private static void Fire(Wave w)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00aa: 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_00ae: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (w.ring <= 0f)
			{
				Carve(center + Vector3.down * w.sink, w.radius);
				return;
			}
			float num = Random.value * MathF.PI * 2f;
			RaycastHit val3 = default(RaycastHit);
			for (int i = 0; i < w.count; i++)
			{
				float num2 = num + MathF.PI * 2f * ((float)i + Random.Range(-0.2f, 0.2f)) / (float)w.count;
				float num3 = w.ring * Random.Range(0.85f, 1.15f);
				Vector3 val = center + new Vector3(Mathf.Cos(num2) * num3, 0f, Mathf.Sin(num2) * num3);
				Vector3 val2 = val + Vector3.up * 12f;
				Vector3 down = Vector3.down;
				LayerIndex world = LayerIndex.world;
				if (Physics.Raycast(val2, down, ref val3, 40f, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1))
				{
					val.y = ((RaycastHit)(ref val3)).point.y;
				}
				Carve(val + Vector3.down * w.sink, w.radius);
			}
		}

		private static void Carve(Vector3 pos, float r)
		{
			//IL_0012: 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)
			r = Mathf.Min(r, ModOptions.MaxCarveRadius.Value);
			VoxelTerrainManager.RequestCarve(pos, r);
			NetMessageExtensions.Send((INetMessage)(object)new CarveMessage(pos, r), (NetworkDestination)1);
		}
	}
	[HarmonyPatch(typeof(SceneExitController), "SetState")]
	internal static class SceneExitTeleportOutPatch
	{
		private static void Postfix(SceneExitController __instance, ExitState newState)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((int)newState == 2 && NetworkServer.active)
				{
					FarewellBlast.Trigger(((Component)__instance).transform.position);
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogError((object)$"[ScorchedVoxels] farewell blast trigger failed: {arg}");
			}
		}
	}
	internal static class FixedStepMeter
	{
		[DefaultExecutionOrder(-30000)]
		internal sealed class FixedHead : MonoBehaviour
		{
			private void FixedUpdate()
			{
				long timestamp = Stopwatch.GetTimestamp();
				if (frameSteps > 0 && tailAt != 0L)
				{
					physTicks += timestamp - tailAt;
				}
				stepStart = timestamp;
			}
		}

		[DefaultExecutionOrder(30000)]
		internal sealed class FixedTail : MonoBehaviour
		{
			private void FixedUpdate()
			{
				long timestamp = Stopwatch.GetTimestamp();
				frameTicks += timestamp - stepStart;
				tailAt = timestamp;
				frameSteps++;
			}
		}

		private static bool spawned;

		internal static long stepStart;

		internal static long tailAt;

		internal static long frameTicks;

		internal static long physTicks;

		internal static int frameSteps;

		public static void EnsureSpawned()
		{
			//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_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!spawned)
			{
				spawned = true;
				GameObject val = new GameObject("ScorchedVoxelsFixedMeter");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<FixedHead>();
				val.AddComponent<FixedTail>();
			}
		}

		public static long TakeFrameTicks(out int steps, out long physics)
		{
			long result = frameTicks;
			steps = frameSteps;
			physics = physTicks;
			frameTicks = 0L;
			physTicks = 0L;
			frameSteps = 0;
			tailAt = 0L;
			return result;
		}
	}
	internal static class GoreCutCore
	{
		public delegate int SplitVertFn(int lo, int hi, float s);

		private static int C(int[] canon, int x)
		{
			if (canon == null || x >= canon.Length)
			{
				return x;
			}
			return canon[x];
		}

		public static void Classify(float[] d, List<int>[] ext, bool sphere, SplitVertFn splitAt, List<int>[] coreT, List<int>[] farT, out bool dropped, List<int>[] biteT = null)
		{
			dropped = false;
			for (int i = 0; i < ext.Length; i++)
			{
				List<int> list = ext[i];
				for (int j = 0; j + 2 < list.Count; j += 3)
				{
					int num = list[j];
					int num2 = list[j + 1];
					int num3 = list[j + 2];
					bool flag = d[num] > 0f;
					bool flag2 = d[num2] > 0f;
					bool flag3 = d[num3] > 0f;
					if (flag && flag2 && flag3)
					{
						List<int> obj = (sphere ? farT[i] : coreT[i]);
						obj.Add(num);
						obj.Add(num2);
						obj.Add(num3);
						continue;
					}
					if (!flag && !flag2 && !flag3)
					{
						if (sphere)
						{
							dropped = true;
							if (biteT != null)
							{
								biteT[i].Add(num);
								biteT[i].Add(num2);
								biteT[i].Add(num3);
							}
						}
						else
						{
							farT[i].Add(num);
							farT[i].Add(num2);
							farT[i].Add(num3);
						}
						continue;
					}
					if (sphere)
					{
						dropped = true;
						if (biteT != null)
						{
							biteT[i].Add(num);
							biteT[i].Add(num2);
							biteT[i].Add(num3);
						}
						continue;
					}
					int num4;
					int num5;
					int num6;
					bool flag4;
					if (flag2 == flag3)
					{
						num4 = num;
						num5 = num2;
						num6 = num3;
						flag4 = flag;
					}
					else if (flag == flag3)
					{
						num4 = num2;
						num5 = num3;
						num6 = num;
						flag4 = flag2;
					}
					else
					{
						num4 = num3;
						num5 = num;
						num6 = num2;
						flag4 = flag3;
					}
					int item = SplitEdge(splitAt, d, num4, num5);
					int item2 = SplitEdge(splitAt, d, num6, num4);
					List<int> list2 = (flag4 ? coreT[i] : farT[i]);
					List<int> obj2 = (flag4 ? farT[i] : coreT[i]);
					list2.Add(num4);
					list2.Add(item);
					list2.Add(item2);
					obj2.Add(item);
					obj2.Add(num5);
					obj2.Add(num6);
					obj2.Add(item);
					obj2.Add(num6);
					obj2.Add(item2);
				}
			}
		}

		private static int SplitEdge(SplitVertFn splitAt, float[] d, int a, int b)
		{
			int num = ((a < b) ? a : b);
			int num2 = ((a < b) ? b : a);
			float num3 = d[num] / (d[num] - d[num2]);
			if (num3 < 0.001f)
			{
				num3 = 0.001f;
			}
			else if (num3 > 0.999f)
			{
				num3 = 0.999f;
			}
			return splitAt(num, num2, num3);
		}

		public static void SphereKeep(List<int>[] farT, List<int>[] coreT, int coreVert, int total, int[] canon = null)
		{
			int[] uf = NewUnionFind(total);
			UnionTris(uf, farT, canon);
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			foreach (List<int> list in farT)
			{
				for (int j = 0; j + 2 < list.Count; j += 3)
				{
					int key = Find(uf, C(canon, list[j]));
					dictionary.TryGetValue(key, out var value);
					dictionary[key] = value + 1;
				}
			}
			int num = -1;
			if (coreVert >= 0 && coreVert < total)
			{
				int num2 = Find(uf, C(canon, coreVert));
				if (dictionary.ContainsKey(num2))
				{
					num = num2;
				}
			}
			if (num < 0)
			{
				int num3 = -1;
				foreach (KeyValuePair<int, int> item in dictionary)
				{
					if (item.Value > num3)
					{
						num3 = item.Value;
						num = item.Key;
					}
				}
			}
			for (int k = 0; k < farT.Length; k++)
			{
				List<int> list2 = farT[k];
				List<int> list3 = coreT[k];
				List<int> list4 = new List<int>();
				for (int l = 0; l + 2 < list2.Count; l += 3)
				{
					List<int> obj = ((Find(uf, C(canon, list2[l])) == num) ? list3 : list4);
					obj.Add(list2[l]);
					obj.Add(list2[l + 1]);
					obj.Add(list2[l + 2]);
				}
				farT[k] = list4;
			}
		}

		public static List<List<int>[]> Components(List<int>[] farT, int total, int[] canon = null)
		{
			int[] uf = NewUnionFind(total);
			UnionTris(uf, farT, canon);
			Dictionary<int, List<int>[]> dictionary = new Dictionary<int, List<int>[]>();
			List<List<int>[]> list = new List<List<int>[]>();
			for (int i = 0; i < farT.Length; i++)
			{
				List<int> list2 = farT[i];
				for (int j = 0; j + 2 < list2.Count; j += 3)
				{
					int key = Find(uf, C(canon, list2[j]));
					if (!dictionary.TryGetValue(key, out var value))
					{
						value = new List<int>[farT.Length];
						for (int k = 0; k < farT.Length; k++)
						{
							value[k] = new List<int>();
						}
						dictionary[key] = value;
						list.Add(value);
					}
					value[i].Add(list2[j]);
					value[i].Add(list2[j + 1]);
					value[i].Add(list2[j + 2]);
				}
			}
			return list;
		}

		private static void UnionTris(int[] uf, List<int>[] tris, int[] canon)
		{
			foreach (List<int> list in tris)
			{
				for (int j = 0; j + 2 < list.Count; j += 3)
				{
					Union(uf, C(canon, list[j]), C(canon, list[j + 1]));
					Union(uf, C(canon, list[j]), C(canon, list[j + 2]));
				}
			}
		}

		private static int[] NewUnionFind(int size)
		{
			int[] array = new int[size];
			for (int i = 0; i < size; i++)
			{
				array[i] = i;
			}
			return array;
		}

		private static int Find(int[] uf, int x)
		{
			while (uf[x] != x)
			{
				uf[x] = uf[uf[x]];
				x = uf[x];
			}
			return x;
		}

		private static void Union(int[] uf, int a, int b)
		{
			int num = Find(uf, a);
			int num2 = Find(uf, b);
			if (num != num2)
			{
				uf[num] = num2;
			}
		}
	}
	internal static class GoreDebug
	{
		private struct PendingKill
		{
			public CharacterMaster master;

			public byte element;

			public uint overkill;

			public float at;
		}

		private const int FormatVersion = 2;

		private const int MagicHeader = 1146312275;

		private const int MagicTrailer = 1162760004;

		private const int MaxFullMeshVerts = 250000;

		private static readonly List<PendingKill> pendingKills = new List<PendingKill>();

		private static readonly Dictionary<uint, (byte elem, uint ovk)> forcedKills = new Dictionary<uint, (byte, uint)>();

		private static readonly (byte elem, string name)[] Lineup = new(byte, string)[10]
		{
			(0, "plain"),
			(1, "fire"),
			(2, "helfire"),
			(3, "acid"),
			(4, "blight"),
			(5, "ice"),
			(6, "lightning"),
			(7, "void"),
			(8, "lunar"),
			(9, "nano")
		};

		public static void Tick()
		{
			bool flag = ModOptions.TestButtons != null && ModOptions.TestButtons.Value;
			if (GoreSkeleton.RecordCuts && !flag)
			{
				GoreSkeleton.ClearCutLog();
			}
			GoreSkeleton.RecordCuts = flag;
			if (flag && !GoreProf.On)
			{
				GoreProf.ResetWindow(Time.time);
			}
			GoreProf.On = flag;
			if (flag)
			{
				FixedStepMeter.EnsureSpawned();
			}
			if (!flag)
			{
				if (pendingKills.Count > 0)
				{
					pendingKills.Clear();
				}
				if (forcedKills.Count > 0)
				{
					forcedKills.Clear();
				}
				return;
			}
			if (Input.GetKeyDown((KeyCode)288))
			{
				SpawnGolem();
			}
			if (Input.GetKeyDown((KeyCode)289))
			{
				SaveScene();
			}
			if (Input.GetKeyDown((KeyCode)290))
			{
				SpawnElementLineup(Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303));
			}
			if (Input.GetKeyDown((KeyCode)291))
			{
				LiveBiteUnderCrosshair(Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303));
			}
			DrainPendingKills();
		}

		private static void LiveBiteUnderCrosshair(bool big)
		{
			//IL_0018: 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)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_00a0: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				return;
			}
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)main).transform.position, ((Component)main).transform.forward);
			Ray val2 = val;
			LayerIndex entityPrecise = LayerIndex.entityPrecise;
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(val2, ref val3, 140f, LayerMask.op_Implicit(((LayerIndex)(ref entityPrecise)).mask), (QueryTriggerInteraction)2))
			{
				HurtBox component = ((Component)((RaycastHit)(ref val3)).collider).GetComponent<HurtBox>();
				HealthComponent val4 = (((Object)(object)component != (Object)null) ? component.healthComponent : null);
				CharacterBody val5 = (((Object)(object)val4 != (Object)null) ? val4.body : null);
				if (!((Object)(object)val5 == (Object)null) && val4.alive)
				{
					bool flag = GoreSkeleton.LiveBite(val5, ((RaycastHit)(ref val3)).point, ((Ray)(ref val)).direction * 5f, big ? 1f : 0.4f);
					ScorchedVoxelsPlugin.Log.LogInfo((object)("[gore debug] F10 live bite on " + ((Object)val5).name + ": " + (flag ? "accepted" : "declined (gates)")));
				}
			}
		}

		public static void Reset()
		{
			pendingKills.Clear();
			forcedKills.Clear();
		}

		private static void SpawnElementLineup(bool overkill)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0158: 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_0161: 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_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: 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_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_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: 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_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || (Object)(object)Run.instance == (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"F9: needs an active run as host/singleplayer.");
				return;
			}
			LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
			CharacterBody val = ((firstLocalUser != null) ? firstLocalUser.cachedBody : null);
			if ((Object)(object)val == (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"F9: no local player body.");
				return;
			}
			GameObject val2 = MasterCatalog.FindMasterPrefab("MagmaWormMaster") ?? MasterCatalog.FindMasterPrefab("LemurianMaster");
			if ((Object)(object)val2 == (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"F9: MasterCatalog has no 'MagmaWormMaster'.");
				return;
			}
			Vector3 val3 = (((Object)(object)val.inputBank != (Object)null) ? val.inputBank.aimDirection : ((Component)val).transform.forward);
			val3.y = 0f;
			val3 = ((((Vector3)(ref val3)).sqrMagnitude > 0.01f) ? ((Vector3)(ref val3)).normalized : Vector3.forward);
			Vector3 val4 = Vector3.Cross(Vector3.up, val3);
			Vector3 normalized = ((Vector3)(ref val4)).normalized;
			float time = Time.time;
			RaycastHit val7 = default(RaycastHit);
			for (int i = 0; i < Lineup.Length; i++)
			{
				float num = ((float)i - (float)(Lineup.Length - 1) * 0.5f) * 14f;
				Vector3 val5 = val.footPosition + val3 * 30f + normalized * num + Vector3.up * 4f;
				Vector3 val6 = val5;
				Vector3 down = Vector3.down;
				LayerIndex world = LayerIndex.world;
				val5 = ((!Physics.Raycast(val6, down, ref val7, 60f, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1)) ? (val.footPosition + val3 * 24f + normalized * num) : ((RaycastHit)(ref val7)).point);
				CharacterMaster val8 = new MasterSummon
				{
					masterPrefab = val2,
					position = val5,
					rotation = Quaternion.LookRotation(-val3),
					teamIndexOverride = (TeamIndex)2,
					ignoreTeamMemberLimit = true,
					useAmbientLevel = true
				}.Perform();
				if (!((Object)(object)val8 == (Object)null))
				{
					pendingKills.Add(new PendingKill
					{
						master = val8,
						element = Lineup[i].elem,
						overkill = (overkill ? 256u : 0u),
						at = time + 2f + (float)i * 0.4f
					});
				}
			}
			ScorchedVoxelsPlugin.Log.LogInfo((object)("F9: WORM element lineup spawned (" + (overkill ? "OVERKILL" : "normal") + "), left to right: " + string.Join(", ", Array.ConvertAll(Lineup, ((byte elem, string name) e) => e.name))));
		}

		private static void DrainPendingKills()
		{
			//IL_0095: 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_00bf: 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)
			if (pendingKills.Count == 0)
			{
				return;
			}
			float time = Time.time;
			for (int num = pendingKills.Count - 1; num >= 0; num--)
			{
				PendingKill pendingKill = pendingKills[num];
				if ((Object)(object)pendingKill.master == (Object)null)
				{
					pendingKills.RemoveAt(num);
				}
				else
				{
					CharacterBody body = pendingKill.master.GetBody();
					if (!((Object)(object)body == (Object)null) && !(time < pendingKill.at))
					{
						try
						{
							HealthComponent healthComponent = body.healthComponent;
							if ((Object)(object)healthComponent != (Object)null && healthComponent.alive)
							{
								Dictionary<uint, (byte elem, uint ovk)> dictionary = forcedKills;
								NetworkInstanceId netId = ((NetworkBehaviour)body).netId;
								dictionary[((NetworkInstanceId)(ref netId)).Value] = (pendingKill.element, pendingKill.overkill);
								healthComponent.Suicide((GameObject)null, (GameObject)null, default(DamageTypeCombo));
							}
						}
						catch (Exception arg)
						{
							ScorchedVoxelsPlugin.Log.LogWarning((object)$"F9: lineup kill failed: {arg}");
						}
						pendingKills.RemoveAt(num);
					}
				}
			}
		}

		internal static void ApplyForcedKill(uint netId, ref GoreSystem.Blow blow)
		{
			if (forcedKills.Count != 0 && forcedKills.TryGetValue(netId, out (byte, uint) value))
			{
				forcedKills.Remove(netId);
				(blow.element, _) = value;
				if (value.Item2 != 0)
				{
					blow.overkill = value.Item2;
				}
			}
		}

		private static void SpawnGolem()
		{
			//IL_0094: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_013c: 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_0144: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || (Object)(object)Run.instance == (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"F7: needs an active run as host/singleplayer.");
				return;
			}
			LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
			CharacterBody val = ((firstLocalUser != null) ? firstLocalUser.cachedBody : null);
			if ((Object)(object)val == (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"F7: no local player body.");
				return;
			}
			GameObject val2 = MasterCatalog.FindMasterPrefab("GolemMaster");
			if ((Object)(object)val2 == (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"F7: MasterCatalog has no 'GolemMaster'.");
				return;
			}
			Vector3 val3 = (((Object)(object)val.inputBank != (Object)null) ? val.inputBank.aimDirection : ((Component)val).transform.forward);
			val3.y = 0f;
			val3 = ((((Vector3)(ref val3)).sqrMagnitude > 0.01f) ? ((Vector3)(ref val3)).normalized : Vector3.forward);
			Vector3 val4 = val.footPosition + val3 * 9f + Vector3.up * 4f;
			Vector3 val5 = val4;
			Vector3 down = Vector3.down;
			LayerIndex world = LayerIndex.world;
			RaycastHit val6 = default(RaycastHit);
			val4 = ((!Physics.Raycast(val5, down, ref val6, 60f, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1)) ? (val.footPosition + val3 * 6f) : ((RaycastHit)(ref val6)).point);
			if ((Object)(object)new MasterSummon
			{
				masterPrefab = val2,
				position = val4,
				rotation = Quaternion.LookRotation(-val3),
				teamIndexOverride = (TeamIndex)2,
				ignoreTeamMemberLimit = true,
				useAmbientLevel = true
			}.Perform() != (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)$"F7: Golem spawned at {val4}.");
			}
			else
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"F7: MasterSummon returned null.");
			}
		}

		private static void SaveScene()
		{
			try
			{
				string dir = Path.Combine(Paths.BepInExRootPath, "ScorchedVoxelsDumps", "svdump-" + DateTime.Now.ToString("yyyyMMdd-HHmmss-fff"));
				Directory.CreateDirectory(dir);
				ScreenCapture.CaptureScreenshot(Path.Combine(dir, "screenshot.png"));
				StringBuilder stringBuilder = new StringBuilder();
				byte[] data;
				using (MemoryStream memoryStream = new MemoryStream(16777216))
				{
					using (BinaryWriter w = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true))
					{
						WriteDump(w, stringBuilder);
					}
					data = memoryStream.ToArray();
				}
				string file = Path.Combine(dir, "scene.svdump");
				stringBuilder.AppendLine($"dump bytes: {data.Length}");
				string summaryText = stringBuilder.ToString();
				string profText = GoreProf.Report(Time.time);
				ScorchedVoxelsPlugin.Log.LogInfo((object)("[goreprof]\n" + profText));
				GoreProf.ResetWindow(Time.time);
				Task.Run(delegate
				{
					try
					{
						File.WriteAllBytes(file, data);
						File.WriteAllText(Path.Combine(dir, "scene.txt"), summaryText);
						File.WriteAllText(Path.Combine(dir, "goreprof.txt"), profText);
						ScorchedVoxelsPlugin.Log.LogInfo((object)("F8: scene dump written to " + dir));
					}
					catch (Exception arg2)
					{
						ScorchedVoxelsPlugin.Log.LogError((object)$"F8: dump write failed: {arg2}");
					}
				});
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogError((object)$"F8: dump failed: {arg}");
			}
		}

		private static void WriteDump(BinaryWriter w, StringBuilder summary)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected I4, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			w.Write(1146312275);
			w.Write(2);
			w.Write("0.20.72");
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name ?? "";
			w.Write(text);
			w.Write(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
			w.Write(Time.time);
			w.Write(Time.frameCount);
			summary.AppendLine(string.Format("scene: {0}  mod: {1}  t={2:F1}", text, "0.20.72", Time.time));
			Camera main = Camera.main;
			w.Write((Object)(object)main != (Object)null);
			if ((Object)(object)main != (Object)null)
			{
				WriteV3(w, ((Component)main).transform.position);
				Quaternion rotation = ((Component)main).transform.rotation;
				w.Write(rotation.x);
				w.Write(rotation.y);
				w.Write(rotation.z);
				w.Write(rotation.w);
				w.Write(main.fieldOfView);
			}
			w.Write((int)RenderSettings.ambientMode);
			WriteColor(w, RenderSettings.ambientLight);
			w.Write(RenderSettings.ambientIntensity);
			w.Write(RenderSettings.fog);
			List<Renderer> list = new List<Renderer>();
			for (int i = 0; i < SceneManager.sceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				if (((Scene)(ref sceneAt)).isLoaded)
				{
					GameObject[] rootGameObjects = ((Scene)(ref sceneAt)).GetRootGameObjects();
					foreach (GameObject val in rootGameObjects)
					{
						list.AddRange(val.GetComponentsInChildren<Renderer>(true));
					}
				}
			}
			w.Write(list.Count);
			int num = 0;
			foreach (Renderer item in list)
			{
				if (WriteRenderer(w, item))
				{
					num++;
				}
			}
			summary.AppendLine($"renderers: {list.Count}  (full mesh data: {num})");
			bool active = GoreSystem.Active;
			w.Write(active);
			if (active)
			{
				GoreSystem.WriteDebugPalettes(w);
				List<KeyValuePair<string, Material>> list2 = new List<KeyValuePair<string, Material>>();
				foreach (KeyValuePair<string, Material> item2 in GoreSystem.DebugMaterials())
				{
					if ((Object)(object)item2.Value != (Object)null)
					{
						list2.Add(item2);
					}
				}
				w.Write(list2.Count);
				foreach (KeyValuePair<string, Material> item3 in list2)
				{
					w.Write(item3.Key);
					WriteMaterial(w, item3.Value);
				}
				GoreSkeleton.WriteDebugState(w);
				GoreSkeleton.WriteCutLog(w);
				summary.AppendLine($"gore materials: {list2.Count}  cut records: {GoreSkeleton.CutLog.Count}");
			}
			w.Write(1162760004);
		}

		private static bool WriteRenderer(BinaryWriter w, Renderer r)
		{
			//IL_0081: 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_0095: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			w.Write(PathOf(((Component)r).transform));
			SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((r is SkinnedMeshRenderer) ? r : null);
			MeshFilter val2 = (((Object)(object)val == (Object)null) ? ((Component)r).GetComponent<MeshFilter>() : null);
			byte b = (byte)(((Object)(object)val != (Object)null) ? 1 : ((!((Object)(object)val2 != (Object)null)) ? 2 : 0));
			w.Write(b);
			w.Write(((Component)r).gameObject.activeInHierarchy);
			w.Write(r.enabled);
			w.Write(((Component)r).gameObject.layer);
			WriteMatrix(w, ((Component)r).transform.localToWorldMatrix);
			Bounds bounds = r.bounds;
			WriteV3(w, ((Bounds)(ref bounds)).center);
			WriteV3(w, ((Bounds)(ref bounds)).size);
			w.Write((byte)r.shadowCastingMode);
			Material[] sharedMaterials = r.sharedMaterials;
			w.Write((sharedMaterials != null) ? sharedMaterials.Length : 0);
			if (sharedMaterials != null)
			{
				Material[] array = sharedMaterials;
				foreach (Material val3 in array)
				{
					w.Write((Object)(object)val3 != (Object)null);
					if ((Object)(object)val3 != (Object)null)
					{
						WriteMaterial(w, val3);
					}
				}
			}
			Mesh mesh = (((Object)(object)val != (Object)null) ? val.sharedMesh : (((Object)(object)val2 != (Object)null) ? val2.sharedMesh : null));
			bool flag = WriteMesh(w, mesh);
			if (b == 1)
			{
				WriteSkin(w, val, flag);
			}
			return flag;
		}

		private static void WriteMaterial(BinaryWriter w, Material m)
		{
			//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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected I4, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			w.Write(((Object)m).name ?? "");
			Shader shader = m.shader;
			w.Write(((Object)(object)shader != (Object)null) ? ((Object)shader).name : "");
			w.Write(m.renderQueue);
			string[] array = m.shaderKeywords ?? Array.Empty<string>();
			w.Write(array.Length);
			string[] array2 = array;
			foreach (string text in array2)
			{
				w.Write(text ?? "");
			}
			MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true);
			int num = 0;
			if ((Object)(object)shader != (Object)null)
			{
				int propertyCount = shader.GetPropertyCount();
				for (int j = 0; j < propertyCount; j++)
				{
					long position = memoryStream.Position;
					try
					{
						string propertyName = shader.GetPropertyName(j);
						ShaderPropertyType propertyType = shader.GetPropertyType(j);
						switch ((int)propertyType)
						{
						default:
							goto end_IL_00c5;
						case 2:
						case 3:
							binaryWriter.Write(propertyName);
							binaryWriter.Write((byte)0);
							binaryWriter.Write(m.GetFloat(propertyName));
							break;
						case 0:
							binaryWriter.Write(propertyName);
							binaryWriter.Write((byte)1);
							WriteColor(binaryWriter, m.GetColor(propertyName));
							break;
						case 1:
						{
							binaryWriter.Write(propertyName);
							binaryWriter.Write((byte)2);
							Vector4 vector = m.GetVector(propertyName);
							binaryWriter.Write(vector.x);
							binaryWriter.Write(vector.y);
							binaryWriter.Write(vector.z);
							binaryWriter.Write(vector.w);
							break;
						}
						case 4:
						{
							binaryWriter.Write(propertyName);
							binaryWriter.Write((byte)3);
							Texture texture = m.GetTexture(propertyName);
							binaryWriter.Write(((Object)(object)texture != (Object)null) ? ((Object)texture).name : "");
							binaryWriter.Write(((Object)(object)texture != (Object)null) ? texture.width : 0);
							binaryWriter.Write(((Object)(object)texture != (Object)null) ? texture.height : 0);
							break;
						}
						}
						num++;
						end_IL_00c5:;
					}
					catch
					{
						memoryStream.Position = position;
						memoryStream.SetLength(position);
					}
				}
			}
			w.Write(num);
			binaryWriter.Flush();
			w.Write(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
		}

		private static bool WriteMesh(BinaryWriter w, Mesh mesh)
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0178: 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)
			//IL_01a3: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: 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_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mesh == (Object)null)
			{
				w.Write((byte)0);
				return false;
			}
			bool flag = mesh.isReadable && mesh.vertexCount > 0 && mesh.vertexCount <= 250000;
			w.Write((byte)((!flag) ? 1 : 2));
			w.Write(((Object)mesh).name ?? "");
			w.Write(mesh.vertexCount);
			int subMeshCount = mesh.subMeshCount;
			w.Write(subMeshCount);
			for (int i = 0; i < subMeshCount; i++)
			{
				int value = 0;
				try
				{
					value = (int)mesh.GetIndexCount(i);
				}
				catch
				{
				}
				w.Write(value);
			}
			if (!flag)
			{
				return false;
			}
			int vertexCount = mesh.vertexCount;
			Vector3[] vertices = mesh.vertices;
			Vector3[] array = mesh.normals;
			if (array != null && array.Length != vertexCount)
			{
				array = null;
			}
			Vector4[] array2 = mesh.tangents;
			if (array2 != null && array2.Length != vertexCount)
			{
				array2 = null;
			}
			Vector2[] array3 = mesh.uv;
			if (array3 != null && array3.Length != vertexCount)
			{
				array3 = null;
			}
			Color32[] array4 = mesh.colors32;
			if (array4 != null && array4.Length != vertexCount)
			{
				array4 = null;
			}
			byte b = 0;
			if (array != null)
			{
				b |= 1;
			}
			if (array2 != null)
			{
				b |= 2;
			}
			if (array3 != null)
			{
				b |= 4;
			}
			if (array4 != null)
			{
				b |= 8;
			}
			w.Write(b);
			Vector3[] array5 = vertices;
			foreach (Vector3 v in array5)
			{
				WriteV3(w, v);
			}
			if (array != null)
			{
				array5 = array;
				foreach (Vector3 v2 in array5)
				{
					WriteV3(w, v2);
				}
			}
			if (array2 != null)
			{
				Vector4[] array6 = array2;
				foreach (Vector4 val in array6)
				{
					w.Write(val.x);
					w.Write(val.y);
					w.Write(val.z);
					w.Write(val.w);
				}
			}
			if (array3 != null)
			{
				Vector2[] array7 = array3;
				foreach (Vector2 val2 in array7)
				{
					w.Write(val2.x);
					w.Write(val2.y);
				}
			}
			if (array4 != null)
			{
				Color32[] array8 = array4;
				foreach (Color32 val3 in array8)
				{
					w.Write(val3.r);
					w.Write(val3.g);
					w.Write(val3.b);
					w.Write(val3.a);
				}
			}
			for (int k = 0; k < subMeshCount; k++)
			{
				int[] indices = mesh.GetIndices(k);
				w.Write(indices.Length);
				int[] array9 = indices;
				foreach (int value2 in array9)
				{
					w.Write(value2);
				}
			}
			Bounds bounds = mesh.bounds;
			WriteV3(w, ((Bounds)(ref bounds)).center);
			WriteV3(w, ((Bounds)(ref bounds)).size);
			return true;
		}

		private static void WriteSkin(BinaryWriter w, SkinnedMeshRenderer smr, bool meshWasFull)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			w.Write(PathOf(smr.rootBone));
			w.Write((byte)smr.quality);
			w.Write(smr.updateWhenOffscreen);
			Transform[] array = smr.bones ?? Array.Empty<Transform>();
			w.Write(array.Length);
			Transform[] array2 = array;
			foreach (Transform val in array2)
			{
				w.Write(PathOf(val));
				WriteMatrix(w, ((Object)(object)val != (Object)null) ? val.localToWorldMatrix : Matrix4x4.identity);
			}
			Mesh sharedMesh = smr.sharedMesh;
			Matrix4x4[] array3 = (((Object)(object)sharedMesh != (Object)null) ? sharedMesh.bindposes : null);
			w.Write((array3 != null) ? array3.Length : 0);
			if (array3 != null)
			{
				Matrix4x4[] array4 = array3;
				foreach (Matrix4x4 m in array4)
				{
					WriteMatrix(w, m);
				}
			}
			BoneWeight[] array5 = null;
			if (meshWasFull && (Object)(object)sharedMesh != (Object)null)
			{
				try
				{
					array5 = sharedMesh.boneWeights;
				}
				catch
				{
				}
			}
			w.Write((array5 != null) ? array5.Length : 0);
			if (array5 != null)
			{
				BoneWeight[] array6 = array5;
				for (int i = 0; i < array6.Length; i++)
				{
					BoneWeight val2 = array6[i];
					w.Write(((BoneWeight)(ref val2)).boneIndex0);
					w.Write(((BoneWeight)(ref val2)).boneIndex1);
					w.Write(((BoneWeight)(ref val2)).boneIndex2);
					w.Write(((BoneWeight)(ref val2)).boneIndex3);
					w.Write(((BoneWeight)(ref val2)).weight0);
					w.Write(((BoneWeight)(ref val2)).weight1);
					w.Write(((BoneWeight)(ref val2)).weight2);
					w.Write(((BoneWeight)(ref val2)).weight3);
				}
			}
		}

		private static string PathOf(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(((Object)t).name);
			Transform parent = t.parent;
			while ((Object)(object)parent != (Object)null)
			{
				stringBuilder.Insert(0, '/');
				stringBuilder.Insert(0, ((Object)parent).name);
				parent = parent.parent;
			}
			return stringBuilder.ToString();
		}

		private static void WriteV3(BinaryWriter w, Vector3 v)
		{
			//IL_0001: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			w.Write(v.x);
			w.Write(v.y);
			w.Write(v.z);
		}

		private static void WriteColor(BinaryWriter w, Color c)
		{
			//IL_0001: 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_0019: 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)
			w.Write(c.r);
			w.Write(c.g);
			w.Write(c.b);
			w.Write(c.a);
		}

		private static void WriteMatrix(BinaryWriter w, Matrix4x4 m)
		{
			for (int i = 0; i < 16; i++)
			{
				w.Write(((Matrix4x4)(ref m))[i]);
			}
		}
	}
	internal sealed class GoreGib : MonoBehaviour
	{
		internal int paletteIdx;

		internal int splatBudget;

		private float nextSplat;

		private void OnCollisionEnter(Collision collision)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (splatBudget <= 0)
				{
					return;
				}
				float time = Time.time;
				if (!(time < nextSplat))
				{
					Vector3 relativeVelocity = collision.relativeVelocity;
					float sqrMagnitude = ((Vector3)(ref relativeVelocity)).sqrMagnitude;
					if (!(sqrMagnitude < 4f) && collision.contactCount != 0)
					{
						nextSplat = time + 0.12f;
						splatBudget--;
						ContactPoint contact = collision.GetContact(0);
						GoreSystem.SplatFromGib(((ContactPoint)(ref contact)).point + ((ContactPoint)(ref contact)).normal * 0.01f, ((ContactPoint)(ref contact)).normal, paletteIdx, Mathf.Sqrt(sqrMagnitude));
					}
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreGib collision failed: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(BlastAttack), "Fire")]
	internal static class GoreBlastRecordPatch
	{
		private static void Postfix(BlastAttack __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (NetworkServer.active && GoreSystem.Active)
				{
					GoreSystem.RecordBlast(__instance.position, __instance.radius);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(OverlapAttack), "Fire")]
	internal static class GoreMeleeRecordPatch
	{
		private static void Postfix(OverlapAttack __instance)
		{
			//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_0076: 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_008e: 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_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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_01c0: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!NetworkServer.active || !GoreSystem.Active)
				{
					return;
				}
				HitBoxGroup hitBoxGroup = __instance.hitBoxGroup;
				if ((Object)(object)hitBoxGroup == (Object)null || hitBoxGroup.hitBoxes == null)
				{
					return;
				}
				Transform val = null;
				float num = 0f;
				HitBox[] hitBoxes = hitBoxGroup.hitBoxes;
				foreach (HitBox val2 in hitBoxes)
				{
					if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy)
					{
						Transform transform = ((Component)val2).transform;
						Vector3 lossyScale = transform.lossyScale;
						float num2 = Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Max(Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)));
						if (num2 > num)
						{
							num = num2;
							val = transform;
						}
					}
				}
				if (!((Object)(object)val == (Object)null) && !(num < 0.4f))
				{
					Vector3 val3 = val.lossyScale * 0.5f;
					((Vector3)(ref val3))..ctor(Mathf.Min(Mathf.Abs(val3.x), 4f), Mathf.Min(Mathf.Abs(val3.y), 4f), Mathf.Min(Mathf.Abs(val3.z), 4f));
					if (val3.x <= val3.y && val3.x <= val3.z)
					{
						val3.x = Mathf.Clamp(val3.x, 0.2f, 0.3f);
					}
					else if (val3.y <= val3.z)
					{
						val3.y = Mathf.Clamp(val3.y, 0.2f, 0.3f);
					}
					else
					{
						val3.z = Mathf.Clamp(val3.z, 0.2f, 0.3f);
					}
					GoreSystem.RecordSlab(__instance.attacker, val.position, val.rotation, val3);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(BulletAttack), "DefaultHitCallbackImplementation")]
	internal static class GoreBulletHitPatch
	{
		private static void Postfix(BulletAttack bulletAttack, ref BulletHit hitInfo)
		{
			try
			{
				GoreSystem.OnBulletHit(ref hitInfo);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(GenericDamageOrb), "OnArrival")]
	internal static class GoreOrbArrivalPatch
	{
		private static void Postfix(GenericDamageOrb __instance)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0055: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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)
			try
			{
				if (NetworkServer.active && GoreSystem.Active)
				{
					HurtBox target = ((Orb)__instance).target;
					HealthComponent val = (((Object)(object)target != (Object)null) ? target.healthComponent : null);
					if (!((Object)(object)val == (Object)null) && val.alive)
					{
						Vector3 position = ((Component)target).transform.position;
						Vector3 dir = position - ((Orb)__instance).origin;
						dir = ((((Vector3)(ref dir)).sqrMagnitude > 0.01f) ? ((Vector3)(ref dir)).normalized : Vector3.forward);
						byte flavor = ((__instance is HuntressArrowOrb) ? ((byte)1) : ((byte)0));
						GoreSystem.ServerWound(target, val, position, dir, flavor);
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(ProjectileSingleTargetImpact), "OnProjectileImpact")]
	internal static class GoreSingleTargetImpactPatch
	{
		private static readonly FieldInfo AliveField = AccessTools.Field(typeof(ProjectileSingleTargetImpact), "alive");

		private static void Prefix(ProjectileSingleTargetImpact __instance, out bool __state)
		{
			__state = true;
			if (!NetworkServer.active || !GoreSystem.Active || AliveField == null)
			{
				return;
			}
			try
			{
				__state = (bool)AliveField.GetValue(__instance);
			}
			catch
			{
				__state = true;
			}
		}

		private static void Postfix(ProjectileSingleTargetImpact __instance, ProjectileImpactInfo impactInfo, ProjectileController ___projectileController, bool __state)
		{
			//IL_0031: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!NetworkServer.active || !GoreSystem.Active || !__state || (Object)(object)___projectileController == (Object)null || ___projectileController.isPrediction)
				{
					return;
				}
				Collider collider = impactInfo.collider;
				if ((Object)(object)collider == (Object)null)
				{
					return;
				}
				HurtBox component = ((Component)collider).GetComponent<HurtBox>();
				HealthComponent val = (((Object)(object)component != (Object)null) ? component.healthComponent : null);
				if (!((Object)(object)val == (Object)null) && val.alive && !((Object)(object)((Component)val).gameObject == (Object)(object)___projectileController.owner) && FriendlyFireManager.ShouldDirectHitProceed(val, ___projectileController.teamFilter.teamIndex))
				{
					byte flavor = 0;
					if ((Object)(object)((Component)__instance).GetComponent<ProjectileHealOwnerOnDamageInflicted>() != (Object)null)
					{
						flavor = 3;
					}
					else if (((Object)__instance).name.StartsWith("RailgunnerPistolProjectile"))
					{
						flavor = 2;
					}
					GoreSystem.ServerWound(component, val, impactInfo.estimatedPointOfImpact, ((Component)__instance).transform.forward, flavor);
				}
			}
			catch
			{
			}
		}
	}
	internal class GoreDeathMessage : INetMessage, ISerializableObject
	{
		private uint netId;

		private GoreSystem.Blow blow;

		public GoreDeathMessage()
		{
		}

		public GoreDeathMessage(uint netId, GoreSystem.Blow blow)
		{
			this.netId = netId;
			this.blow = blow;
		}

		public void Serialize(NetworkWriter writer)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0095: 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)
			writer.WritePackedUInt32(netId);
			writer.Write(blow.kind);
			writer.Write(blow.pos);
			writer.Write(blow.force);
			writer.WritePackedUInt32(blow.PackAux());
			if (blow.kind == 1)
			{
				writer.Write(blow.radius);
			}
			if (blow.kind == 2)
			{
				writer.Write(blow.slabPos);
				writer.Write(blow.slabRot);
				writer.Write(blow.slabHalf);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0098: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			netId = reader.ReadPackedUInt32();
			blow = new GoreSystem.Blow
			{
				kind = reader.ReadByte(),
				pos = reader.ReadVector3(),
				force = reader.ReadVector3()
			};
			blow.UnpackAux(reader.ReadPackedUInt32());
			if (blow.kind == 1)
			{
				blow.radius = reader.ReadSingle();
			}
			if (blow.kind == 2)
			{
				blow.slabPos = reader.ReadVector3();
				blow.slabRot = reader.ReadQuaternion();
				blow.slabHalf = reader.ReadVector3();
			}
		}

		public void OnReceived()
		{
			//IL_0027: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active && ModOptions.Enabled.Value && ModOptions.GoreEnabled.Value && GoreSystem.Finite(blow.pos) && GoreSystem.Finite(blow.force) && GoreSystem.Finite(blow.slabPos) && GoreSystem.Finite(blow.slabHalf) && float.IsFinite(blow.radius) && float.IsFinite(blow.slabRot.x) && float.IsFinite(blow.slabRot.y) && float.IsFinite(blow.slabRot.z) && float.IsFinite(blow.slabRot.w))
			{
				GoreSystem.OnDeathFromNet(netId, blow);
			}
		}
	}
	internal class GoreHitMessage : INetMessage, ISerializableObject
	{
		private Vector3 pos;

		private Vector3 dir;

		private byte relay;

		public GoreHitMessage()
		{
		}

		public GoreHitMessage(Vector3 pos, Vector3 dir, bool request)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			this.pos = pos;
			this.dir = dir;
			relay = (request ? ((byte)1) : ((byte)0));
		}

		public void Serialize(NetworkWriter writer)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(pos);
			writer.Write(dir);
			writer.Write(relay);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			pos = reader.ReadVector3();
			dir = reader.ReadVector3();
			relay = reader.ReadByte();
		}

		public void OnReceived()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!ModOptions.Enabled.Value || !ModOptions.GoreEnabled.Value || !GoreSystem.Finite(pos) || !GoreSystem.Finite(dir))
			{
				return;
			}
			if (NetworkServer.active)
			{
				if (relay != 0 && GoreSystem.RelayBulletHit())
				{
					GoreSystem.ApplyBulletBite(pos, dir);
					NetMessageExtensions.Send((INetMessage)(object)new GoreHitMessage(pos, dir, request: false), (NetworkDestination)1);
				}
			}
			else
			{
				GoreSystem.ApplyBulletBite(pos, dir);
			}
		}
	}
	internal class GoreWoundMessage : INetMessage, ISerializableObject
	{
		private uint netId;

		private Vector3 pos;

		private Vector3 dir;

		private byte flavor;

		public GoreWoundMessage()
		{
		}

		public GoreWoundMessage(uint netId, Vector3 pos, Vector3 dir, byte flavor)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			this.netId = netId;
			this.pos = pos;
			this.dir = dir;
			this.flavor = flavor;
		}

		public void Serialize(NetworkWriter writer)
		{
			//IL_000e: 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)
			writer.WritePackedUInt32(netId);
			writer.Write(pos);
			writer.Write(dir);
			writer.Write(flavor);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			netId = reader.ReadPackedUInt32();
			pos = reader.ReadVector3();
			dir = reader.ReadVector3();
			flavor = reader.ReadByte();
		}

		public void OnReceived()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00a2: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active || !ModOptions.Enabled.Value || !ModOptions.GoreEnabled.Value || !GoreSystem.Finite(pos) || !GoreSystem.Finite(dir))
			{
				return;
			}
			try
			{
				GameObject val = ClientScene.FindLocalObject(new NetworkInstanceId(netId));
				CharacterBody val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<CharacterBody>() : null);
				HealthComponent val3 = (((Object)(object)val2 != (Object)null) ? val2.healthComponent : null);
				if ((Object)(object)val3 == (Object)null || !val3.alive)
				{
					if (VoxelTerrainManager.LocalConversionDone)
					{
						GoreSystem.BulletSpray(pos, dir, 0);
					}
					return;
				}
				HurtBox val4 = GoreSystem.ClosestHurtBox(val2, pos);
				if (!((Object)(object)val4 == (Object)null))
				{
					GoreWounds.OnHit(val4, val3, pos, dir, Vector3.zero, flavor);
				}
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("wound message", e);
			}
		}
	}
	internal class GoreLiveBiteMessage : INetMessage, ISerializableObject
	{
		private uint netId;

		private Vector3 pos;

		private Vector3 force;

		private float frac;

		public GoreLiveBiteMessage()
		{
		}

		public GoreLiveBiteMessage(uint netId, Vector3 pos, Vector3 force, float frac)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			this.netId = netId;
			this.pos = pos;
			this.force = force;
			this.frac = frac;
		}

		public void Serialize(NetworkWriter writer)
		{
			//IL_000e: 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)
			writer.WritePackedUInt32(netId);
			writer.Write(pos);
			writer.Write(force);
			writer.Write(frac);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			netId = reader.ReadPackedUInt32();
			pos = reader.ReadVector3();
			force = reader.ReadVector3();
			frac = reader.ReadSingle();
		}

		public void OnReceived()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active || !ModOptions.Enabled.Value || !ModOptions.GoreEnabled.Value || !GoreSystem.Finite(pos) || !GoreSystem.Finite(force) || !float.IsFinite(frac))
			{
				return;
			}
			try
			{
				GameObject val = ClientScene.FindLocalObject(new NetworkInstanceId(netId));
				CharacterBody val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<CharacterBody>() : null);
				if (!((Object)(object)val2 == (Object)null))
				{
					GoreSkeleton.LiveBite(val2, pos, force, frac, fromWire: true);
				}
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("live bite message", e);
			}
		}
	}
	internal static class GoreProf
	{
		public const int TickWorkerApply = 0;

		public const int TickRagdoll = 1;

		public const int TickCutCapture = 2;

		public const int TickInnards = 3;

		public const int TickCorpses = 4;

		public const int TickPieces = 5;

		public const int ApplyCut = 6;

		public const int ApplyInnardsSlot = 7;

		public const int PieceSpawn = 8;

		public const int DeathRegister = 9;

		public const int ElemStartSlot = 10;

		public const int ElemEat = 11;

		public const int ElemFire = 12;

		public const int ElemIce = 13;

		public const int ElemLightning = 14;

		public const int ElemVoid = 15;

		public const int ElemLunar = 16;

		public const int PieceElem = 17;

		public const int TintCorpse = 18;

		public const int FxMotes = 19;

		public const int FxArc = 20;

		public const int FxSizzle = 21;

		public const int FxPool = 22;

		public const int FxImplosion = 23;

		public const int FxSmoke = 24;

		public const int FxDribble = 25;

		public const int FxJolt = 26;

		public const int SysDrops = 27;

		public const int SysSplats = 28;

		public const int SysStains = 29;

		public const int SysSparks = 30;

		public const int SysWounds = 31;

		public const int StainBuckets = 32;

		public const int ModDebris = 33;

		public const int ModNodeGraph = 34;

		public const int ModTerrain = 35;

		public const int ModMisc = 36;

		public const int OvHud = 37;

		public const int OvCards = 38;

		public const int OvReveal = 39;

		public const int OvAnim = 40;

		public const int OvArcade = 41;

		public const int HookBlast = 42;

		public const int HookDamage = 43;

		public const int PieceRecut = 44;

		public const int WkCutCompute = 45;

		public const int WkInnardsCompute = 46;

		private const int FirstWorkerSlot = 45;

		private const int SlotCount = 47;

		private static readonly string[] Names = new string[47]
		{
			"tick:worker-apply", "tick:ragdoll", "tick:cut-capture", "tick:innards-dispatch", "tick:corpses", "tick:pieces", "apply:cut", "apply:innards", "piece:spawn", "death:register",
			"elem:start", "elem:eat(acid/blight/nano)", "elem:fire", "elem:ice", "elem:lightning", "elem:void", "elem:lunar", "elem:pieces", "tint:corpse", "fx:motes",
			"fx:arc", "fx:sizzle", "fx:pool", "fx:implosion", "fx:smoke", "fx:dribble", "fx:jolt", "sys:drops", "sys:splats", "stain:drain",
			"sys:sparks", "sys:wounds", "stain:buckets", "mod:debris", "mod:nodegraph", "mod:terrain-uploads", "mod:farewell", "overlay:hud", "overlay:cards", "overlay:reveal",
			"overlay:anim", "overlay:arcade", "hook:blast/gouge", "hook:damage", "piece:recut", "cut-compute (worker)", "innards-compute (worker)"
		};

		public static bool On;

		private static readonly long[] total = new long[47];

		private static readonly long[] worst = new long[47];

		private static readonly int[] calls = new int[47];

		private static readonly long[] frameCur = new long[47];

		private static readonly long[] frameWorst = new long[47];

		private static readonly long[] frameLast = new long[47];

		private static float windowStart;

		private static int frames;

		private static float lastFrameMs;

		private static double lastFixedScriptsMs;

		private static double lastPhysicsMs;

		private static int lastFixedSteps;

		private static int lastGcD;

		private const int RingSize = 16;

		private const double RingFloorMs = 2.0;

		private static readonly long[] ringTicks = new long[16];

		private static readonly int[] ringSlot = new int[16];

		private static readonly int[] ringFrame = new int[16];

		private static int f20;

		private static int f33;

		private static int f50;

		private static double fSumMs;

		private static double fWorstMs;

		private const int SlowRing = 12;

		private const float SlowFloorMs = 25f;

		private static readonly float[] slowMs = new float[12];

		private static readonly float[] slowGoreMs = new float[12];

		private static readonly float[] slowFixedMs = new float[12];

		private static readonly byte[] slowGc = new byte[12];

		private static readonly byte[] slowSteps = new byte[12];

		private static readonly short[] slowRbs = new short[12];

		private static readonly short[] slowPieces = new short[12];

		private static readonly int[] slowFrame = new int[12];

		private static int lastGc0;

		private static float lastFixedTime;

		private static readonly int[] TopLevelSlots = new int[15]
		{
			0, 1, 2, 3, 4, 5, 9, 27, 28, 29,
			30, 31, 32, 42, 43
		};

		private static int curLockFrames;

		private static double curLockMs;

		private static int lockRuns;

		private static int worstLockFrames;

		private static double worstLockMs;

		private static void LockTrack(float ms)
		{
			if (ms >= 100f)
			{
				curLockFrames++;
				curLockMs += ms;
				return;
			}
			if (curLockFrames >= 3)
			{
				lockRuns++;
				if (curLockMs > worstLockMs)
				{
					worstLockMs = curLockMs;
					worstLockFrames = curLockFrames;
				}
			}
			curLockFrames = 0;
			curLockMs = 0.0;
		}

		public static long Begin()
		{
			if (!On)
			{
				return 0L;
			}
			return Stopwatch.GetTimestamp();
		}

		public static void End(int slot, long t0)
		{
			if (t0 == 0L)
			{
				return;
			}
			long num = Stopwatch.GetTimestamp() - t0;
			total[slot] += num;
			calls[slot]++;
			if (num > worst[slot])
			{
				worst[slot] = num;
			}
			if (slot < 45)
			{
				frameCur[slot] += num;
			}
			if (!((double)num * 1000.0 / (double)Stopwatch.Frequency >= 2.0))
			{
				return;
			}
			int num2 = 0;
			for (int i = 1; i < 16; i++)
			{
				if (ringTicks[i] < ringTicks[num2])
				{
					num2 = i;
				}
			}
			if (num > ringTicks[num2])
			{
				ringTicks[num2] = num;
				ringSlot[num2] = slot;
				ringFrame[num2] = frames;
			}
		}

		public static void FrameRoll(int liveRbs, int pieceCount)
		{
			if (!On)
			{
				return;
			}
			frames++;
			long num = 0L;
			int[] topLevelSlots = TopLevelSlots;
			foreach (int num2 in topLevelSlots)
			{
				num += frameCur[num2];
			}
			for (int j = 0; j < 45; j++)
			{
				if (frameCur[j] > frameWorst[j])
				{
					frameWorst[j] = frameCur[j];
				}
				frameLast[j] = frameCur[j];
				frameCur[j] = 0L;
			}
			lastFixedScriptsMs = Ms(FixedStepMeter.TakeFrameTicks(out lastFixedSteps, out var physics));
			lastPhysicsMs = Ms(physics);
			float num3 = (lastFrameMs = Time.unscaledDeltaTime * 1000f);
			fSumMs += num3;
			if ((double)num3 > fWorstMs)
			{
				fWorstMs = num3;
			}
			if (num3 >= 20f)
			{
				f20++;
			}
			if (num3 >= 33f)
			{
				f33++;
			}
			if (num3 >= 50f)
			{
				f50++;
			}
			LockTrack(num3);
			int num4 = GC.CollectionCount(0);
			int num5 = Mathf.Clamp(num4 - lastGc0, 0, 9);
			lastGc0 = num4;
			lastGcD = num5;
			float fixedTime = Time.fixedTime;
			int num6 = Mathf.Clamp(Mathf.RoundToInt((fixedTime - lastFixedTime) / Mathf.Max(Time.fixedDeltaTime, 0.0001f)), 0, 15);
			lastFixedTime = fixedTime;
			if (num3 < 25f)
			{
				return;
			}
			int num7 = 0;
			for (int k = 1; k < 12; k++)
			{
				if (slowMs[k] < slowMs[num7])
				{
					num7 = k;
				}
			}
			if (!(num3 <= slowMs[num7]))
			{
				slowMs[num7] = num3;
				slowGoreMs[num7] = (float)Ms(num);
				slowFixedMs[num7] = (float)lastFixedScriptsMs;
				slowGc[num7] = (byte)num5;
				slowSteps[num7] = (byte)num6;
				slowRbs[num7] = (short)Mathf.Clamp(liveRbs, 0, 32767);
				slowPieces[num7] = (short)Mathf.Clamp(pieceCount, 0, 32767);
				slowFrame[num7] = frames;
			}
		}

		public static void ResetWindow(float now)
		{
			Array.Clear(total, 0, 47);
			Array.Clear(worst, 0, 47);
			Array.Clear(calls, 0, 47);
			Array.Clear(frameCur, 0, 47);
			Array.Clear(frameWorst, 0, 47);
			Array.Clear(ringTicks, 0, 16);
			Array.Clear(slowMs, 0, 12);
			Array.Clear(slowFixedMs, 0, 12);
			f20 = (f33 = (f50 = 0));
			fSumMs = (fWorstMs = 0.0);
			curLockFrames = 0;
			curLockMs = 0.0;
			lockRuns = 0;
			worstLockFrames = 0;
			worstLockMs = 0.0;
			lastGc0 = GC.CollectionCount(0);
			lastFixedTime = Time.fixedTime;
			windowStart = now;
			frames = 0;
		}

		private static double Ms(long ticks)
		{
			return (double)ticks * 1000.0 / (double)Stopwatch.Frequency;
		}

		public unsafe static string TopLine()
		{
			byte* intPtr = stackalloc byte[20];
			// IL initblk instruction
			Unsafe.InitBlock(intPtr, 255, 20);
			Span<int> span = new Span<int>(intPtr, 5);
			for (int i = 0; i < 47; i++)
			{
				if (calls[i] == 0)
				{
					continue;
				}
				for (int j = 0; j < 5; j++)
				{
					if (span[j] < 0 || total[i] > total[span[j]])
					{
						for (int num = 4; num > j; num--)
						{
							span[num] = span[num - 1];
						}
						span[j] = i;
						break;
					}
				}
			}
			StringBuilder stringBuilder = new StringBuilder("[goreprof] top: ");
			bool flag = false;
			for (int k = 0; k < 5; k++)
			{
				if (span[k] >= 0)
				{
					if (flag)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append(Names[span[k]]).Append(' ').Append(Ms(total[span[k]]).ToString("F0"))
						.Append("ms");
					flag = true;
				}
			}
			if (!flag)
			{
				stringBuilder.Append("(quiet)");
			}
			if (frames > 0)
			{
				stringBuilder.Append($" | frames >33ms: {f33}, worst {fWorstMs:F0}ms");
			}
			return stringBuilder.ToString();
		}

		public static string Report(float now)
		{
			StringBuilder stringBuilder = new StringBuilder(4096);
			stringBuilder.AppendLine($"goreprof window: {now - windowStart:F1}s, {frames} frames");
			stringBuilder.AppendLine("slots nest (tick:corpses > elem:* > tint/fx; apply:cut > piece:spawn);");
			stringBuilder.AppendLine("worst-frame is the stutter column; (worker) slots are latency, not frame cost");
			stringBuilder.AppendLine();
			int[] array2;
			if (frames > 0)
			{
				bool flag = !Physics.GetIgnoreLayerCollision(LayerIndex.ragdoll.intVal, LayerIndex.ragdoll.intVal);
				stringBuilder.AppendLine($"frame watchdog: avg {fSumMs / (double)frames:F1}ms, worst {fWorstMs:F1}ms;" + $" >20ms {f20}, >33ms {f33}, >50ms {f50}" + "  (ragdoll-vs-ragdoll collision: " + (flag ? "ON" : "off") + "; overlay screen alive: " + (LoadingOverlay.ScreenAlive ? "YES" : "no") + ")");
				double num = curLockMs;
				int num2 = curLockFrames;
				double num3 = Math.Max(worstLockMs, (num2 >= 3) ? num : 0.0);
				int num4 = ((worstLockMs >= num || num2 < 3) ? worstLockFrames : num2);
				int num5 = lockRuns + ((num2 >= 3) ? 1 : 0);
				if (num5 > 0)
				{
					stringBuilder.AppendLine($"*** LOCKS (3+ consecutive 100ms+ frames): {num5} run(s)," + $" longest {num3 / 1000.0:F1}s over {num4} frames ***");
				}
				int[] array = new int[12];
				for (int i = 0; i < 12; i++)
				{
					array[i] = i;
				}
				Array.Sort(array, (int a, int b) => slowMs[b].CompareTo(slowMs[a]));
				bool flag2 = false;
				array2 = array;
				foreach (int num7 in array2)
				{
					if (!(slowMs[num7] <= 0f))
					{
						if (!flag2)
						{
							stringBuilder.AppendLine("slowest frames — the WHOLE frame vs the gore slots' share of it:");
							flag2 = true;
						}
						float num8 = ((slowMs[num7] > 0f) ? (slowGoreMs[num7] / slowMs[num7] * 100f) : 0f);
						stringBuilder.AppendLine($"  {slowMs[num7],6:F1}ms  gore {slowGoreMs[num7],5:F1}ms ({num8:F0}%)" + $"  fixed-scripts {slowFixedMs[num7]:F0}ms," + $" gc0 +{slowGc[num7]}, phys steps {slowSteps[num7]}," + $" rbs {slowRbs[num7]}, pieces {slowPieces[num7]}  (frame {slowFrame[num7]})");
					}
				}
				stringBuilder.AppendLine();
			}
			stringBuilder.AppendLine(string.Format("{0,-28} {1,7} {2,10} {3,8} {4,9} {5,11}", "name", "calls", "total ms", "avg ms", "worst ms", "worst-frame"));
			int[] array3 = new int[47];
			for (int num9 = 0; num9 < 47; num9++)
			{
				array3[num9] = num9;
			}
			Array.Sort(array3, (int a, int b) => total[b].CompareTo(total[a]));
			array2 = array3;
			foreach (int num10 in array2)
			{
				if (calls[num10] != 0)
				{
					string arg = ((num10 < 45) ? Ms(frameWorst[num10]).ToString("F1") : "-");
					stringBuilder.AppendLine($"{Names[num10],-28} {calls[num10],7} {Ms(total[num10]),10:F1} " + $"{Ms(total[num10]) / (double)calls[num10],8:F3} {Ms(worst[num10]),9:F1} {arg,11}");
				}
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("worst single events (>= 2ms):");
			int[] array4 = new int[16];
			for (int num11 = 0; num11 < 16; num11++)
			{
				array4[num11] = num11;
			}
			Array.Sort(array4, (int a, int b) => ringTicks[b].CompareTo(ringTicks[a]));
			array2 = array4;
			foreach (int num12 in array2)
			{
				if (ringTicks[num12] != 0L)
				{
					stringBuilder.AppendLine($"  {Ms(ringTicks[num12]),7:F1}ms  {Names[ringSlot[num12]]}  (frame {ringFrame[num12]})");
				}
			}
			return stringBuilder.ToString();
		}

		public unsafe static string LockAutopsy(int liveRbs, int pieceCount)
		{
			StringBuilder stringBuilder = new StringBuilder(256);
			double num = 0.0;
			double num2 = 0.0;
			int[] topLevelSlots = TopLevelSlots;
			foreach (int num3 in topLevelSlots)
			{
				num += Ms(frameLast[num3]);
			}
			num2 = Ms(frameLast[33]) + Ms(frameLast[34]) + Ms(frameLast[35]) + Ms(frameLast[36]) + Ms(frameLast[37]) + Ms(frameLast[38]) + Ms(frameLast[39]) + Ms(frameLast[40]) + Ms(frameLast[41]);
			double num4 = Math.Max(0.0, (double)lastFrameMs - lastFixedScriptsMs - lastPhysicsMs - num - num2);
			stringBuilder.Append($"frame {lastFrameMs:F0}ms = fixed-scripts {lastFixedScriptsMs:F0}ms").Append($" ({lastFixedSteps} steps) + physics {lastPhysicsMs:F0}ms").Append($" + gore {num:F1}ms + mod {num2:F1}ms")
				.Append($" + render/other {num4:F0}ms; gc0 +{lastGcD},")
				.Append($" rbs {liveRbs}, pieces {pieceCount},")
				.Append($" bodies {CharacterBody.readOnlyInstancesList.Count}");
			byte* intPtr = stackalloc byte[12];
			// IL initblk instruction
			Unsafe.InitBlock(intPtr, 255, 12);
			Span<int> span = new Span<int>(intPtr, 3);
			for (int j = 0; j < 45; j++)
			{
				if (frameLast[j] == 0L)
				{
					continue;
				}
				for (int k = 0; k < 3; k++)
				{
					if (span[k] < 0 || frameLast[j] > frameLast[span[k]])
					{
						for (int num5 = 2; num5 > k; num5--)
						{
							span[num5] = span[num5 - 1];
						}
						span[k] = j;
						break;
					}
				}
			}
			bool flag = false;
			for (int l = 0; l < 3; l++)
			{
				if (span[l] >= 0 && !(Ms(frameLast[span[l]]) < 0.5))
				{
					stringBuilder.Append(flag ? ", " : "; ours: ");
					stringBuilder.Append($"{Names[span[l]]} {Ms(frameLast[span[l]]):F1}");
					flag = true;
				}
			}
			return stringBuilder.ToString();
		}

		public static int ElemSlot(byte elem)
		{
			switch (elem)
			{
			case 3:
			case 4:
			case 9:
				return 11;
			case 1:
			case 2:
				return 12;
			case 5:
				return 13;
			case 6:
				return 14;
			case 7:
				return 15;
			case 8:
				return 16;
			default:
				return 10;
			}
		}
	}
	internal static class GoreSkeleton
	{
		private sealed class BakedMesh
		{
			public bool dead;

			public BoneWeight[] weights;

			public Vector3[] pos;

			public Vector3[] nrm;

			public Matrix4x4[] bindposes;

			public Vector4[] tan;

			public Vector2[] uv;

			public Color32[] col;

			public int[][] ext;

			public int[] canon;

			public float[] boneAcc;

			public int domBone = -1;

			public int domCoreVert = -1;
		}

		private class WarmJob : GoreJobBase
		{
			public override void Compute()
			{
			}

			public override void Apply()
			{
			}
		}

		private class Rend
		{
			public SkinnedMeshRenderer smr;

			public Transform[] bones;

			public bool prepared;

			public bool dead;

			public Mesh owned;

			public GameObject innardsGo;

			public Mesh innardsMesh;

			public BoneWeight[] weights;

			public Vector3[] bindPos;

			public Vector3[] bindNrm;

			public Matrix4x4[] bindposes;

			public Vector2[] bindUv;

			public Vector4[] bindTan;

			public Color32[] bindCol;

			public Matrix4x4[] skinScratch;

			public List<int>[] ext;

			public int coreVert;

			public int[] canon;

			public float[] boneAcc;

			public int domBone = -1;

			public int domCoreVert = -1;

			public bool innardsDirty;

			public bool innardsBusy;

			public List<Vector3> innardsSpots;

			public float bindPerWorld;

			public float nextInnardsAt;

			public int baseVerts;
		}

		private struct SkinSlot
		{
			public Renderer r;

			public Material[] baseMats;
		}

		private struct FrozenSnap
		{
			public GameObject go;

			public Mesh mesh;

			public SkinnedMeshRenderer smr;
		}

		private struct PlantedBone
		{
			public Transform bone;

			public float share;

			public Vector3 axisLocal;

			public float len;

			public float capR;
		}

		private class Corpse
		{
			public Transform modelTf;

			public Transform refBone;

			public readonly List<Rend> rends = new List<Rend>();

			public readonly List<SkinnedMeshRenderer> lateSmrs = new List<SkinnedMeshRenderer>();

			public bool deoptDone;

			public readonly List<Transform> allBones = new List<Transform>();

			public readonly List<Transform> sweepBones = new List<Transform>();

			public Transform coreBone;

			public bool coreReady;

			public Vector3 center;

			public Vector3 boundsSize;

			public int palette;

			public float radius;

			public float expireAt;

			public float lastBite;

			public int cuts;

			public int queued;

			public float sweepUntil;

			public float nextSweepAt;

			public byte element;

			public bool oiled;

			public float elemUntil;

			public float nextElem;

			public int elemStep;

			public float elemPhase;

			public float elemSpan;

			public float ovk;

			public float smokeUntil;

			public float nextSmoke;

			public Animator[] anims;

			public float animLockUntil;

			public float nextStripAt;

			public int totalVerts;

			public readonly List<SkinSlot> skinSlots = new List<SkinSlot>();

			public readonly List<ParticleSystem> meshEmitters = new List<ParticleSystem>();

			public List<PlantedBone> planted;

			public List<Transform> pickedBones;

			public float ragdollMass;

			public bool statueWedged;

			public float unearthAt;

			public int unearthTries;

			public readonly List<Rigidbody> rbs = new List<Rigidbody>();

			public readonly List<FrozenSnap> frozenSnaps = new List<FrozenSnap>();

			public bool rbsReady;

			public bool ragdollPending;

			public float bornAt;

			public bool frozen;

			public float restSince = -1f;

			public float nextLodAt;

			public float fallFloor = float.NegativeInfinity;

			public readonly List<Renderer> tintRends = new List<Renderer>();

			public int tintRendsAtCuts = -1;

			public bool adopted;

			public bool cutBusy;

			public bool alive;

			public int liveBites;

			public float nextLiveBiteAt;
		}

		private class Piece
		{
			public GameObject go;

			public Transform tf;

			public Mesh mesh;

			public MeshFilter mf;

			public MeshCollider col;

			public MeshRenderer mr;

			public int palette;

			public int cuts;

			public int skinVerts;

			public int skinSubs;

			public float dieAt;

			public float killY;

			public float dribbleUntil;

			public float nextDribble;

			public byte element;

			public int dripPalette;

			public Rigidbody rb;

			public bool colSwapped;

			public float born;

			public float phase0;

			public float nextFx;

			public float dissolve = 1f;
		}

		private class DripSource
		{
			public Renderer cap;

			public int palette;

			public float until;

			public float next;

			public float strength = 1f;
		}

		private struct CutReq
		{
			public Corpse c;

			public byte shape;

			public byte style;

			public Vector3 pos;

			public Vector3 dir;

			public float radius;

			public float boost;
		}

		private class PieceGeo
		{
			public Rend rend;

			public readonly List<Vector3> pos = new List<Vector3>();

			public readonly List<Vector3> nrm = new List<Vector3>();

			public readonly List<Vector2> uv = new List<Vector2>();

			public readonly Dictionary<int, int> map = new Dictionary<int, int>(64);

			public List<int>[] tris;

			public List<Vector3> boneSpots;

			public Bounds bounds;

			public bool hasBounds;
		}

		internal sealed class EdgeKeyComparer : IEqualityComparer<long>
		{
			public static readonly EdgeKeyComparer Instance = new EdgeKeyComparer();

			public bool Equals(long x, long y)
			{
				return x == y;
			}

			public int GetHashCode(long k)
			{
				long num = (k ^ (k >>> 33)) * -49064778989728563L;
				long num2 = (num ^ (num >>> 33)) * -4265267296055464877L;
				return (int)(num2 ^ (num2 >>> 33));
			}
		}

		private class RendCut
		{
			public Rend rend;

			public int n;

			public Matrix4x4[] skin;

			public List<Vector3> boneSpots;

			public string meshName;

			public Bounds meshBounds;

			public bool cutHappened;

			public bool computeThrew;

			public bool dropped;

			public Vector3[] wv;

			public List<int>[] coreT;

			public List<int>[] farT;

			public SplitVerts split;

			public Vector3[] newPos;

			public Vector3[] newNrm;

			public Vector4[] newTan;

			public Vector2[] newUv;

			public Color32[] newCol;

			public BoneWeight[] newWeights;

			public int[] newCanon;

			public byte[] bwPerVert;

			public BoneWeight1[] bwFlat;

			public int bwFlatCount;
		}

		private class CutJob : GoreJobBase
		{
			public Corpse c;

			public CutReq req;

			public bool alive;

			public bool wantFlesh;

			public bool wantBone;

			public readonly List<RendCut> rends = new List<RendCut>();

			public readonly List<PieceGeo> geos = new List<PieceGeo>();

			public readonly List<PiecePrep> preps = new List<PiecePrep>();

			public long phSkin;

			public long phClassify;

			public long phGeo;

			public long phRebuild;

			public long phPieces;

			public long ppEdges;

			public long ppShell;

			public int ppTris;

			public override void Compute()
			{
				ComputeCutJob(this);
			}

			public override void Apply()
			{
				ApplyCutJob(this);
			}
		}

		private class SplitVerts
		{
			private readonly Rend rend;

			private readonly Vector3[] wv;

			private readonly Vector3[] wn;

			private readonly Vector3[] bindPos;

			private readonly Vector3[] bindNrm;

			private readonly Vector4[] bindTan;

			private readonly Vector2[] bindUv;

			private readonly Color32[] bindCol;

			public readonly List<Vector3> pos = new List<Vector3>();

			public readonly List<Vector3> nrm = new List<Vector3>();

			public readonly List<Vector4> tan = new List<Vector4>();

			public readonly List<Vector2> uv = new List<Vector2>();

			public readonly List<Color32> col = new List<Color32>();

			public readonly List<BoneWeight> bw = new List<BoneWeight>();

			public readonly List<Vector3> worldPos = new List<Vector3>();

			public readonly List<Vector3> worldNrm = new List<Vector3>();

			private readonly Dictionary<long, int> lookup = new Dictionary<long, int>(EdgeKeyComparer.Instance);

			public int Count => pos.Count;

			public bool HasNrm => bindNrm != null;

			public bool HasTan => bindTan != null;

			public bool HasUv => bindUv != null;

			public bool HasCol => bindCol != null;

			public SplitVerts(Rend rend, Vector3[] wv, Vector3[] wn)
			{
				this.rend = rend;
				this.wv = wv;
				this.wn = wn;
				bindPos = rend.bindPos;
				bindNrm = rend.bindNrm;
				bindTan = rend.bindTan;
				bindUv = rend.bindUv;
				bindCol = rend.bindCol;
			}

			public int At(int lo, int hi, float s)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: 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_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: 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_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				long key = ((long)lo << 32) | (uint)hi;
				if (lookup.TryGetValue(key, out var value))
				{
					return value;
				}
				value = bindPos.Length + pos.Count;
				lookup[key] = value;
				pos.Add(Vector3.LerpUnclamped(bindPos[lo], bindPos[hi], s));
				if (bindNrm != null)
				{
					nrm.Add(Vector3.Slerp(bindNrm[lo], bindNrm[hi], s));
				}
				if (bindTan != null)
				{
					tan.Add(Vector4.LerpUnclamped(bindTan[lo], bindTan[hi], s));
				}
				if (bindUv != null)
				{
					uv.Add(Vector2.LerpUnclamped(bindUv[lo], bindUv[hi], s));
				}
				if (bindCol != null)
				{
					col.Add(Color32.Lerp(bindCol[lo], bindCol[hi], s));
				}
				bw.Add(MergeWeights(rend.weights[lo], rend.weights[hi], s));
				worldPos.Add(Vector3.LerpUnclamped(wv[lo], wv[hi], s));
				worldNrm.Add((wn != null) ? Vector3.Slerp(wn[lo], wn[hi], s) : Vector3.up);
				return value;
			}

			public void World(int localIdx, out Vector3 p, out Vector3 n, out Vector2 u)
			{
				//IL_0008: 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)
				//IL_001f: 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_002e: 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)
				p = worldPos[localIdx];
				n = worldNrm[localIdx];
				u = ((bindUv != null) ? uv[localIdx] : Vector2.zero);
			}

			public Vector3 WorldPos(int localIdx)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return worldPos[localIdx];
			}
		}

		internal sealed class CutRecord
		{
			public string corpse;

			public string rend;

			public byte shape;

			public byte style;

			public Vector3 pos;

			public Vector3 dir;

			public float radius;

			public float boost;

			public float time;

			public int coreVert;

			public int splitCount;

			public bool dropped;

			public Vector3[] wv;

			public int[] canon;

			public int[][] ext;

			public Vector3[] splitPos;

			public int coreTris;

			public int farTris;
		}

		private struct InnardsReq
		{
			public Corpse c;

			public Rend rend;
		}

		private class InnardsJob : GoreJobBase
		{
			public Corpse c;

			public Rend rend;

			public List<Vector3> boneSpots;

			public List<int>[] ext;

			public Vector3[] bindPos;

			public Vector3[] bindNrm;

			public BoneWeight[] weights;

			public int[] canon;

			public float bindPerWorld;

			public bool wantBone;

			public Matrix4x4[] skin;

			public Matrix4x4 skinFallback;

			public bool anyCore;

			public List<Vector3> pos;

			public List<Vector3> nrm;

			public List<int> tris;

			public List<int> boneTris;

			public byte[] bwPerVert;

			public BoneWeight1[] bwFlat;

			public int bwFlatCount;

			public float woundLen;

			public int extTris;

			public long phEdges;

			public long phShell;

			public long phCaps;

			public override void Compute()
			{
				ComputeInnards(this);
			}

			public override void Apply()
			{
				ApplyInnards(this);
			}
		}

		private class PiecePrep
		{
			public PieceGeo geo;

			public List<int> capEdges;

			public float capLen;

			public List<int> fleshTris;

			public List<int> boneTris;

			public Vector3[] local;

			public Vector3 center;

			public int nOuter;
		}

		private struct RagdollReq
		{
			public Corpse c;

			public Vector3 push;

			public RagdollController rag;
		}

		private interface IGoreJob
		{
			void Compute();

			void Apply();
		}

		private abstract class GoreJobBase : IGoreJob
		{
			public Exception error;

			public long computeTicks;

			public abstract void Compute();

			public abstract void Apply();
		}

		private static readonly Dictionary<Mesh, BakedMesh> bakedMeshes = new Dictionary<Mesh, BakedMesh>();

		private static readonly Queue<Mesh> bakeQueue = new Queue<Mesh>();

		private static readonly HashSet<Mesh> bakeQueued = new HashSet<Mesh>();

		private static readonly List<SkinnedMeshRenderer> bakeSmrScratch = new List<SkinnedMeshRenderer>(8);

		private const int MaxCorpses = 48;

		private const int MaxPieces = 32;

		private const int MaxPiecesPerCut = 6;

		private const int MaxCutsPerCorpse = 16;

		private const int MaxQueuedCuts = 24;

		private const int MaxQueuedPerCorpse = 5;

		private const int CutsPerTick = 3;

		private const int InstantKillCutsPerFrame = 2;

		private const int InstantKillCutMaxVerts = 12000;

		private const float CorpseLife = 120f;

		private const float PieceTTL = 12f;

		private const float PieceShrink = 0.7f;

		private const int MinPieceVerts = 12;

		private const float MinPieceSize = 0.08f;

		private const int MaxCutVerts = 60000;

		private const float MinBodySize = 0.5f;

		private const float MaxBodySize = 60f;

		private const float BulletBleedWindow = 0.12f;

		private const float FleshShrink = 0.008f;

		private const float BlastRadiusFrac = 0.35f;

		private const float DribbleTime = 2.2f;

		private const float DribbleStep = 0.22f;

		private const float DripTime = 4f;

		private const float DripStep = 0.4f;

		private const float ColliderSweep = 2.5f;

		private const float SideEps = 0.0001f;

		private const byte ShapePlane = 0;

		private const byte ShapeSphere = 1;

		private const byte StyleSlice = 0;

		private const byte StyleBlast = 1;

		private const byte StyleGouge = 3;

		private const byte StyleCarve = 4;

		private const byte StyleAcid = 5;

		private const byte StyleShatter = 6;

		private const byte StyleCollapse = 7;

		private const byte StyleBite = 8;

		private static readonly List<Corpse> corpses = new List<Corpse>();

		private static readonly Dictionary<Transform, Corpse> byModel = new Dictionary<Transform, Corpse>();

		private static readonly Queue<CutReq> cutQueue = new Queue<CutReq>();

		private static readonly List<Piece> pieces = new List<Piece>();

		private static readonly List<DripSource> drippers = new List<DripSource>();

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

		private static readonly List<Collider> colliderBuf = new List<Collider>(8);

		private static GameObject pieceRoot;

		private static readonly Random rng = new Random(1585320685);

		private static Vector3 tickEye;

		private static bool tickHasEye;

		private const int MaxFullDeathsPerSecond = 12;

		private static float deathWindowStart;

		private static int deathWindowCount;

		private static bool ragdollLayerQuieted;

		private const int MaxLivePileRbs = 120;

		private const int PileFreezesPerTick = 2;

		private static int spiralFrames;

		private static float nextAutopsyAt;

		private static int instantKillBudget;

		private static int instantKillFrame = -1;

		private static int deoptFrame = -1;

		private static readonly List<Mesh> orphanedMeshes = new List<Mesh>();

		[ThreadStatic]
		private static Dictionary<long, int> edgeCountScratch;

		[ThreadStatic]
		private static Dictionary<long, (int a, int b)> edgeReprScratch;

		[ThreadStatic]
		private static int[] mergeIdx;

		[ThreadStatic]
		private static float[] mergeWgt;

		internal static bool RecordCuts;

		private const int MaxCutRecords = 12;

		private static readonly List<CutRecord> cutLog = new List<CutRecord>();

		private const float AcidEatTime = 7f;

		private const float AcidHuskFade = 0.3f;

		private const float CharTime = 4.2f;

		private const float FrostGlintTime = 2.6f;

		private const float JoltTime = 1.5f;

		private const float VoidPulseTime = 1.3f;

		private const float LunarHymnTime = 3f;

		private static readonly Color CharSkin = new Color(0.1f, 0.085f, 0.075f);

		private static readonly Color EmberGlow = new Color(1.4f, 0.38f, 0.07f);

		private static readonly Color HelfireGlow = new Color(0.35f, 0.62f, 1.5f);

		private static readonly Color AcidSkin = new Color(0.3f, 0.5f, 0.14f);

		private static readonly Color AcidPulse = new Color(0.3f, 1.1f, 0.1f);

		private static readonly Color BlightSkin = new Color(0.5f, 0.38f, 0.1f);

		private static readonly Color BlightPulse = new Color(1.1f, 0.62f, 0.06f);

		private static readonly Color NanoSkin = new Color(0.42f, 0.5f, 0.5f);

		private static readonly Color NanoPulse = new Color(0.3f, 0.85f, 0.75f);

		private static readonly Color FrostSkin = new Color(0.62f, 0.8f, 1f);

		private static readonly Color FrostGlow = new Color(0.1f, 0.24f, 0.45f);

		private static readonly Color ArcGlow = new Color(0.8f, 1.1f, 1.6f);

		private static readonly Color VoidGlow = new Color(0.55f, 0.15f, 0.95f);

		private static readonly Color LunarGlow = new Color(0.55f, 0.68f, 1.3f);

		private static MaterialPropertyBlock tintBlock;

		private static readonly List<Renderer> tintScratch = new List<Renderer>(16);

		private const float EatBiteMaxDist = 70f;

		private const int EatBitesPerSecond = 12;

		private static float eatWindowStart;

		private static int eatWindowCount;

		private static readonly int PropColor = Shader.PropertyToID("_Color");

		private static readonly int PropEmColor = Shader.PropertyToID("_EmColor");

		private static readonly int PropEmission = Shader.PropertyToID("_EmissionColor");

		private static readonly int PropEmPower = Shader.PropertyToID("_EmPower");

		private static readonly int PropSmoothness = Shader.PropertyToID("_Smoothness");

		private static readonly List<InnardsReq> innardsQueue = new List<InnardsReq>();

		private const int MaxInnardsDispatchPerTick = 2;

		private const float InnardsCooldown = 0.4f;

		private const int FullShellMaxTris = 8000;

		private const int MaxLiveBites = 3;

		private const int MaxLiveRigs = 12;

		private const float LiveBiteGap = 0.5f;

		private const float LiveBiteRadiusMin = 0.18f;

		private const float LiveBiteRadiusMax = 2.2f;

		private static readonly HashSet<Transform> liveDeclined = new HashSet<Transform>();

		private const int PieceFullShellMaxTris = 4000;

		private const int PieceSpawnsPerSecond = 24;

		private static float pieceWindowStart;

		private static int pieceWindowCount;

		private const int MaxPieceCuts = 2;

		private static readonly List<Piece> recutScratch = new List<Piece>(32);

		private const int MaxRagdollBones = 12;

		private const int RagdollBuildsPerTick = 2;

		private const float MaxStatueBoxSide = 12f;

		private const float AdoptedGrace = 3f;

		private static readonly Queue<RagdollReq> ragdollQueue = new Queue<RagdollReq>();

		private const long RagdollBudgetMs = 6L;

		private const float AnimLockTime = 3f;

		private const float LodNearRadius = 45f;

		private const float LodRestSpeed = 0.4f;

		private const float LodRestHold = 0.75f;

		private const float LodRestHoldNear = 1.25f;

		private const float LodStep = 0.45f;

		private static readonly List<Rigidbody> rbScratch = new List<Rigidbody>(24);

		private static readonly List<SkinnedMeshRenderer> lodSmrScratch = new List<SkinnedMeshRenderer>(16);

		private static readonly MaterialPropertyBlock mpbScratch = new MaterialPropertyBlock();

		private static readonly List<Material> restoreScratch = new List<Material>(8);

		private static Thread goreWorker;

		private static readonly ConcurrentQueue<IGoreJob> workerIn = new ConcurrentQueue<IGoreJob>();

		private static readonly ConcurrentQueue<IGoreJob> workerOut = new ConcurrentQueue<IGoreJob>();

		private static readonly AutoResetEvent workerWake = new AutoResetEvent(initialState: false);

		private static bool GlobalQueueFull => cutQueue.Count >= 24;

		internal static IReadOnlyList<CutRecord> CutLog => cutLog;

		internal static void QueueBake(CharacterBody body)
		{
			Transform val = (((Object)(object)body.modelLocator != (Object)null) ? body.modelLocator.modelTransform : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			((Component)val).GetComponentsInChildren<SkinnedMeshRenderer>(true, bakeSmrScratch);
			foreach (SkinnedMeshRenderer item in bakeSmrScratch)
			{
				Mesh val2 = (((Object)(object)item != (Object)null) ? item.sharedMesh : null);
				if (!((Object)(object)val2 == (Object)null) && !bakedMeshes.ContainsKey(val2) && bakeQueued.Add(val2))
				{
					bakeQueue.Enqueue(val2);
				}
			}
			bakeSmrScratch.Clear();
		}

		private static void DrainBakeQueue()
		{
			while (bakeQueue.Count > 0)
			{
				Mesh val = bakeQueue.Dequeue();
				bakeQueued.Remove(val);
				if (!((Object)(object)val == (Object)null) && !bakedMeshes.ContainsKey(val))
				{
					try
					{
						GetBaked(val);
						break;
					}
					catch (Exception e)
					{
						GoreSystem.WarnThrottled("gore mesh bake", e);
						break;
					}
				}
			}
		}

		private static BakedMesh GetBaked(Mesh mesh)
		{
			if (bakedMeshes.TryGetValue(mesh, out var value))
			{
				return value;
			}
			if (!ModOptions.TestButtons.Value)
			{
				value = BakeMeshData(mesh);
			}
			else
			{
				Stopwatch stopwatch = Stopwatch.StartNew();
				value = BakeMeshData(mesh);
				if (stopwatch.ElapsedMilliseconds >= 2)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)$"[gore timing] inline bake '{((Object)mesh).name}': {stopwatch.ElapsedMilliseconds}ms");
				}
			}
			bakedMeshes[mesh] = value;
			return value;
		}

		internal static void WarmCutPath()
		{
			//IL_0038: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: 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)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: 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_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			int num = 50;
			Vector3[] array = (Vector3[])(object)new Vector3[num];
			Vector3[] array2 = (Vector3[])(object)new Vector3[num];
			BoneWeight[] array3 = (BoneWeight[])(object)new BoneWeight[num];
			for (int i = 0; i <= 24; i++)
			{
				array[i * 2] = new Vector3((float)i * 0.1f, 0f, 0f);
				array[i * 2 + 1] = new Vector3((float)i * 0.1f, 0.1f, 0f);
				array2[i * 2] = Vector3.forward;
				array2[i * 2 + 1] = Vector3.forward;
				int num2 = i * 2;
				BoneWeight val = default(BoneWeight);
				((BoneWeight)(ref val)).boneIndex0 = 0;
				((BoneWeight)(ref val)).weight0 = 0.6f;
				((BoneWeight)(ref val)).boneIndex1 = 1;
				((BoneWeight)(ref val)).weight1 = 0.4f;
				array3[num2] = val;
				int num3 = i * 2 + 1;
				val = default(BoneWeight);
				((BoneWeight)(ref val)).boneIndex0 = 1;
				((BoneWeight)(ref val)).weight0 = 1f;
				array3[num3] = val;
			}
			List<int> list = new List<int>(144);
			for (int j = 0; j < 24; j++)
			{
				int num4 = j * 2;
				list.Add(num4);
				list.Add(num4 + 2);
				list.Add(num4 + 3);
				list.Add(num4);
				list.Add(num4 + 3);
				list.Add(num4 + 1);
			}
			Rend rend = new Rend();
			rend.bones = (Transform[])(object)new Transform[2];
			rend.weights = array3;
			rend.bindPos = array;
			rend.bindNrm = array2;
			rend.bindposes = (Matrix4x4[])(object)new Matrix4x4[2]
			{
				Matrix4x4.identity,
				Matrix4x4.identity
			};
			rend.canon = BuildCanon(array, num);
			rend.ext = new List<int>[1] { list };
			Rend rend2 = rend;
			Matrix4x4[] skin = (Matrix4x4[])(object)new Matrix4x4[2]
			{
				Matrix4x4.identity,
				Matrix4x4.identity
			};
			Vector3[] array4 = (Vector3[])(object)new Vector3[num];
			Vector3[] wn = (Vector3[])(object)new Vector3[num];
			SkinPoints(rend2, skin, array4, wn);
			float[] array5 = new float[num];
			for (int k = 0; k < num; k++)
			{
				float num5 = 1.2f - array4[k].x;
				array5[k] = ((Mathf.Abs(num5) < 0.0001f) ? 0.0001f : num5);
			}
			List<int>[] coreT = new List<int>[1]
			{
				new List<int>()
			};
			List<int>[] farT = new List<int>[1]
			{
				new List<int>()
			};
			SplitVerts splitVerts = new SplitVerts(rend2, array4, wn);
			GoreCutCore.Classify(array5, rend2.ext, sphere: false, splitVerts.At, coreT, farT, out var dropped);
			GoreCutCore.Components(farT, num + splitVerts.Count, rend2.canon);
			for (int l = 0; l < num; l++)
			{
				Vector3 val2 = array4[l] - new Vector3(0.6f, 0.05f, 0f);
				float num6 = ((Vector3)(ref val2)).magnitude - 0.18f;
				array5[l] = ((Mathf.Abs(num6) < 0.0001f) ? 0.0001f : num6);
			}
			List<int>[] coreT2 = new List<int>[1]
			{
				new List<int>()
			};
			List<int>[] farT2 = new List<int>[1]
			{
				new List<int>()
			};
			List<int>[] biteT = new List<int>[1]
			{
				new List<int>()
			};
			SplitVerts splitVerts2 = new SplitVerts(rend2, array4, wn);
			GoreCutCore.Classify(array5, rend2.ext, sphere: true, splitVerts2.At, coreT2, farT2, out dropped, biteT);
			GoreCutCore.SphereKeep(farT2, coreT2, 0, num + splitVerts2.Count, rend2.canon);
			CutJob cutJob = new CutJob
			{
				req = new CutReq
				{
					shape = 0,
					pos = new Vector3(1.2f, 0f, 0f),
					dir = Vector3.left
				},
				alive = false,
				wantFlesh = false,
				wantBone = false
			};
			cutJob.rends.Add(new RendCut
			{
				rend = rend2,
				n = num,
				skin = skin,
				meshName = "warmstrip",
				meshBounds = new Bounds(Vector3.zero, Vector3.one)
			});
			try
			{
				ComputeCutJob(cutJob);
			}
			catch
			{
			}
			SubmitJob(new WarmJob());
			string[] array6 = new string[8] { "ExecuteCut", "CaptureRendCut", "ApplyCutJob", "ApplyRendCut", "SpawnPiecePrepared", "CaptureInnards", "ComputeInnards", "ApplyInnards" };
			foreach (string name in array6)
			{
				try
				{
					MethodInfo method = typeof(GoreSkeleton).GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic);
					if (method != null)
					{
						RuntimeHelpers.PrepareMethod(method.MethodHandle);
					}
				}
				catch
				{
				}
			}
		}

		private static bool ColdRend(Rend r)
		{
			if (!r.prepared)
			{
				if ((Object)(object)r.smr != (Object)null && (Object)(object)r.smr.sharedMesh != (Object)null)
				{
					return !bakedMeshes.ContainsKey(r.smr.sharedMesh);
				}
				return true;
			}
			return false;
		}

		private static void ResetBakes()
		{
			bakedMeshes.Clear();
			bakeQueue.Clear();
			bakeQueued.Clear();
		}

		private static BakedMesh BakeMeshData(Mesh mesh)
		{
			//IL_0092: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			BakedMesh bakedMesh = new BakedMesh
			{
				dead = true
			};
			if (!mesh.isReadable)
			{
				if (loggedMeshes.Add(((Object)mesh).name))
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)("GoreSkeleton: mesh '" + ((Object)mesh).name + "' is not CPU-readable; that renderer keeps the vanilla death."));
				}
				return bakedMesh;
			}
			if (mesh.blendShapeCount > 0)
			{
				return bakedMesh;
			}
			int vertexCount = mesh.vertexCount;
			if (vertexCount < 3 || vertexCount > 60000)
			{
				return bakedMesh;
			}
			BoneWeight[] boneWeights = mesh.boneWeights;
			if (boneWeights == null || boneWeights.Length != vertexCount)
			{
				return bakedMesh;
			}
			Matrix4x4[] bindposes = mesh.bindposes;
			if (bindposes == null || bindposes.Length == 0)
			{
				return bakedMesh;
			}
			for (int i = 0; i < mesh.subMeshCount; i++)
			{
				if ((int)mesh.GetTopology(i) != 0)
				{
					return bakedMesh;
				}
			}
			bakedMesh.weights = boneWeights;
			bakedMesh.pos = mesh.vertices;
			Vector3[] normals = mesh.normals;
			bakedMesh.nrm = ((normals != null && normals.Length == vertexCount) ? normals : null);
			bakedMesh.bindposes = bindposes;
			Vector4[] tangents = mesh.tangents;
			bakedMesh.tan = ((tangents != null && tangents.Length == vertexCount) ? tangents : null);
			Vector2[] uv = mesh.uv;
			bakedMesh.uv = ((uv != null && uv.Length == vertexCount) ? uv : null);
			Color32[] colors = mesh.colors32;
			bakedMesh.col = ((colors != null && colors.Length == vertexCount) ? colors : null);
			bakedMesh.ext = new int[mesh.subMeshCount][];
			for (int j = 0; j < mesh.subMeshCount; j++)
			{
				bakedMesh.ext[j] = mesh.GetTriangles(j);
			}
			bakedMesh.canon = BuildCanon(bakedMesh.pos, vertexCount);
			float[] array = new float[bindposes.Length];
			for (int k = 0; k < vertexCount; k += 4)
			{
				BoneWeight val = boneWeights[k];
				if ((uint)((BoneWeight)(ref val)).boneIndex0 < (uint)array.Length)
				{
					array[((BoneWeight)(ref val)).boneIndex0] += ((BoneWeight)(ref val)).weight0;
				}
				if ((uint)((BoneWeight)(ref val)).boneIndex1 < (uint)array.Length)
				{
					array[((BoneWeight)(ref val)).boneIndex1] += ((BoneWeight)(ref val)).weight1;
				}
				if ((uint)((BoneWeight)(ref val)).boneIndex2 < (uint)array.Length)
				{
					array[((BoneWeight)(ref val)).boneIndex2] += ((BoneWeight)(ref val)).weight2;
				}
				if ((uint)((BoneWeight)(ref val)).boneIndex3 < (uint)array.Length)
				{
					array[((BoneWeight)(ref val)).boneIndex3] += ((BoneWeight)(ref val)).weight3;
				}
			}
			bakedMesh.boneAcc = array;
			float num = 0f;
			for (int l = 0; l < array.Length; l++)
			{
				if (array[l] > num)
				{
					num = array[l];
					bakedMesh.domBone = l;
				}
			}
			if (bakedMesh.domBone >= 0)
			{
				float num2 = 0f;
				for (int m = 0; m < vertexCount; m++)
				{
					BoneWeight val2 = boneWeights[m];
					float num3 = 0f;
					if (((BoneWeight)(ref val2)).boneIndex0 == bakedMesh.domBone)
					{
						num3 += ((BoneWeight)(ref val2)).weight0;
					}
					if (((BoneWeight)(ref val2)).boneIndex1 == bakedMesh.domBone)
					{
						num3 += ((BoneWeight)(ref val2)).weight1;
					}
					if (((BoneWeight)(ref val2)).boneIndex2 == bakedMesh.domBone)
					{
						num3 += ((BoneWeight)(ref val2)).weight2;
					}
					if (((BoneWeight)(ref val2)).boneIndex3 == bakedMesh.domBone)
					{
						num3 += ((BoneWeight)(ref val2)).weight3;
					}
					if (num3 > num2)
					{
						num2 = num3;
						bakedMesh.domCoreVert = m;
						if (num3 > 0.75f)
						{
							break;
						}
					}
				}
			}
			bakedMesh.dead = false;
			return bakedMesh;
		}

		private static bool TakeDeathBudget()
		{
			float time = Time.time;
			if (time - deathWindowStart >= 1f)
			{
				deathWindowStart = time;
				deathWindowCount = 0;
			}
			if (deathWindowCount >= 12)
			{
				return false;
			}
			deathWindowCount++;
			return true;
		}

		public static void Reset()
		{
			ragdollQueue.Clear();
			innardsQueue.Clear();
			ResetBakes();
			foreach (Corpse corpse in corpses)
			{
				if (corpse.adopted && (Object)(object)corpse.modelTf != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)corpse.modelTf).gameObject);
				}
			}
			cutQueue.Clear();
			cutLog.Clear();
			foreach (Corpse corpse2 in corpses)
			{
				if (corpse2.alive && (Object)(object)corpse2.modelTf != (Object)null)
				{
					ForgetOwnedMeshes(corpse2);
				}
				else
				{
					DropOwnedMeshes(corpse2);
				}
			}
			foreach (Mesh orphanedMesh in orphanedMeshes)
			{
				if ((Object)(object)orphanedMesh != (Object)null)
				{
					Object.Destroy((Object)(object)orphanedMesh);
				}
			}
			orphanedMeshes.Clear();
			corpses.Clear();
			byModel.Clear();
			liveDeclined.Clear();
			for (int num = pieces.Count - 1; num >= 0; num--)
			{
				DestroyPiece(num);
			}
			pieces.Clear();
			drippers.Clear();
			if ((Object)(object)pieceRoot != (Object)null)
			{
				Object.Destroy((Object)(object)pieceRoot);
			}
			pieceRoot = null;
		}

		public static void Tick()
		{
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_083c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a31: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a35: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Unknown result type (might be due to invalid IL or missing references)
			//IL_088a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a61: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0621: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0942: Unknown result type (might be due to invalid IL or missing references)
			//IL_0947: Unknown result type (might be due to invalid IL or missing references)
			//IL_0954: Unknown result type (might be due to invalid IL or missing references)
			if (!GoreSystem.Active && corpses.Count == 0 && pieces.Count == 0 && cutQueue.Count == 0 && drippers.Count == 0)
			{
				return;
			}
			float time = Time.time;
			if (!ragdollLayerQuieted && corpses.Count > 0)
			{
				ragdollLayerQuieted = true;
				Physics.IgnoreLayerCollision(LayerIndex.ragdoll.intVal, LayerIndex.ragdoll.intVal, true);
			}
			int num = 0;
			if (GoreProf.On)
			{
				foreach (Corpse corpse3 in corpses)
				{
					if (!corpse3.frozen)
					{
						num += corpse3.rbs.Count;
					}
				}
				GoreProf.FrameRoll(num, pieces.Count);
			}
			if (Time.unscaledDeltaTime >= 0.1f)
			{
				spiralFrames++;
			}
			else
			{
				spiralFrames = 0;
			}
			if (spiralFrames >= 2)
			{
				spiralFrames = 0;
				int num2 = 0;
				int num3 = 0;
				foreach (Corpse corpse4 in corpses)
				{
					if (!corpse4.frozen && !corpse4.alive && corpse4.rbsReady && corpse4.rbs.Count != 0)
					{
						num3 += corpse4.rbs.Count;
						num2++;
						try
						{
							FreezeCorpse(corpse4);
						}
						catch (Exception e)
						{
							GoreSystem.WarnThrottled("GoreSkeleton spiral freeze", e);
						}
					}
				}
				if (num2 > 0)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)($"[gore] spiral breaker: froze {num2} corpses ({num3} bodies)" + " after consecutive 100ms+ frames"));
				}
				if (GoreProf.On && time >= nextAutopsyAt)
				{
					nextAutopsyAt = time + 1f;
					ScorchedVoxelsPlugin.Log.LogInfo((object)("[gore] lock autopsy: " + GoreProf.LockAutopsy(num, pieces.Count)));
				}
			}
			long t = GoreProf.Begin();
			DrainWorkerResults();
			GoreProf.End(0, t);
			t = GoreProf.Begin();
			DrainRagdollQueue();
			GoreProf.End(1, t);
			DrainBakeQueue();
			Camera main = Camera.main;
			Vector3 eye = (((Object)(object)main != (Object)null) ? ((Component)main).transform.position : Vector3.zero);
			bool hasEye = (Object)(object)main != (Object)null;
			tickEye = eye;
			tickHasEye = hasEye;
			long t2 = GoreProf.Begin();
			int num4 = 3;
			int count = cutQueue.Count;
			bool flag = false;
			long timestamp = Stopwatch.GetTimestamp();
			while (num4 > 0 && count-- > 0 && cutQueue.Count > 0 && !(PhaseMs(Stopwatch.GetTimestamp() - timestamp) >= 6.0))
			{
				CutReq req = cutQueue.Dequeue();
				req.c.queued--;
				if ((Object)(object)req.c.modelTf == (Object)null || !byModel.TryGetValue(req.c.modelTf, out var value) || value != req.c)
				{
					continue;
				}
				if (req.c.cutBusy)
				{
					Enqueue(req, force: true);
					continue;
				}
				if (!req.c.alive && !req.c.deoptDone && req.c.lateSmrs.Count > 0 && !TakeDeoptBudget())
				{
					Enqueue(req, force: true);
					continue;
				}
				if (!flag)
				{
					foreach (Rend rend in req.c.rends)
					{
						if (ColdRend(rend))
						{
							flag = true;
							break;
						}
					}
				}
				else
				{
					bool flag2 = false;
					foreach (Rend rend2 in req.c.rends)
					{
						if (ColdRend(rend2))
						{
							flag2 = true;
							break;
						}
					}
					if (flag2)
					{
						Enqueue(req, force: true);
						continue;
					}
				}
				num4--;
				try
				{
					ExecuteCut(req.c, req);
				}
				catch (Exception e2)
				{
					GoreSystem.WarnThrottled("GoreSkeleton cut", e2);
				}
			}
			GoreProf.End(2, t2);
			t = GoreProf.Begin();
			DrainInnardsQueue();
			GoreProf.End(3, t);
			t = GoreProf.Begin();
			for (int num5 = corpses.Count - 1; num5 >= 0; num5--)
			{
				try
				{
					Corpse corpse = corpses[num5];
					if ((Object)(object)corpse.modelTf == (Object)null)
					{
						corpses.RemoveAt(num5);
						DropOwnedMeshes(corpse);
					}
					else if (corpse.adopted && time >= corpse.expireAt + 3f)
					{
						GameObject gameObject = ((Component)corpse.modelTf).gameObject;
						corpses.RemoveAt(num5);
						DropOwnedMeshes(corpse);
						Object.Destroy((Object)(object)gameObject);
					}
					else
					{
						if (time < corpse.sweepUntil && time >= corpse.nextSweepAt)
						{
							corpse.nextSweepAt = time + 0.2f;
							SweepSeveredColliders(corpse);
						}
						if (corpse.anims != null && time < corpse.animLockUntil)
						{
							Animator[] anims = corpse.anims;
							foreach (Animator val in anims)
							{
								if ((Object)(object)val != (Object)null && ((Behaviour)val).enabled)
								{
									((Behaviour)val).enabled = false;
								}
							}
						}
						if (corpse.adopted && time < corpse.animLockUntil && time >= corpse.nextStripAt)
						{
							corpse.nextStripAt = time + 0.4f;
							RestoreSkinMaterials(corpse);
						}
						if (corpse.unearthTries > 0 && time >= corpse.unearthAt)
						{
							corpse.unearthTries--;
							corpse.unearthAt = time + 1f;
							TryUnearth(corpse);
						}
						else if (corpse.unearthTries == 0 && time >= corpse.unearthAt && (corpse.statueWedged || (corpse.planted != null && corpse.planted.Count > 0)))
						{
							corpse.unearthAt = time + 4f;
							corpse.unearthTries = 1;
						}
						EvaluateLod(corpse, time, eye, hasEye);
						ElementTick(corpse, time);
					}
				}
				catch (Exception e3)
				{
					GoreSystem.WarnThrottled("GoreSkeleton corpse tick", e3);
				}
			}
			GoreProf.End(4, t);
			int num6 = 0;
			foreach (Corpse corpse5 in corpses)
			{
				if (!corpse5.frozen && !corpse5.alive)
				{
					num6 += corpse5.rbs.Count;
				}
			}
			int num7 = 2;
			while (num6 > 120 && num7-- > 0)
			{
				Corpse corpse2 = null;
				foreach (Corpse corpse6 in corpses)
				{
					if (!corpse6.frozen && !corpse6.alive && corpse6.rbsReady && corpse6.rbs.Count != 0 && (corpse2 == null || corpse6.bornAt < corpse2.bornAt))
					{
						corpse2 = corpse6;
					}
				}
				if (corpse2 == null)
				{
					break;
				}
				num6 -= corpse2.rbs.Count;
				try
				{
					FreezeCorpse(corpse2);
				}
				catch (Exception e4)
				{
					GoreSystem.WarnThrottled("GoreSkeleton pile freeze", e4);
					break;
				}
			}
			if (byModel.Count != corpses.Count)
			{
				byModel.Clear();
				foreach (Corpse corpse7 in corpses)
				{
					if ((Object)(object)corpse7.modelTf != (Object)null)
					{
						byModel[corpse7.modelTf] = corpse7;
					}
				}
			}
			t = GoreProf.Begin();
			for (int num8 = pieces.Count - 1; num8 >= 0; num8--)
			{
				try
				{
					Piece piece = pieces[num8];
					if ((Object)(object)piece.go == (Object)null)
					{
						DestroyPiece(num8);
					}
					else
					{
						float num9 = piece.dieAt - time;
						if (num9 <= 0f || piece.tf.position.y < piece.killY)
						{
							DestroyPiece(num8);
						}
						else
						{
							if (num9 < 0.7f)
							{
								piece.tf.localScale = Vector3.one * (piece.dissolve * Mathf.Max(num9 / 0.7f, 0.05f));
							}
							else
							{
								PieceElementTick(piece, time);
							}
							if (time < piece.dribbleUntil && time >= piece.nextDribble)
							{
								piece.nextDribble = time + 0.22f;
								GoreSystem.Dribble(piece.tf.position, piece.dripPalette);
							}
							if (!piece.colSwapped && (Object)(object)piece.col != (Object)null && (Object)(object)piece.rb != (Object)null && !piece.rb.isKinematic && piece.rb.IsSleeping())
							{
								piece.colSwapped = true;
								BoxCollider obj = piece.go.AddComponent<BoxCollider>();
								Bounds bounds = piece.mesh.bounds;
								obj.center = ((Bounds)(ref bounds)).center;
								obj.size = ((Bounds)(ref bounds)).size;
								((Collider)obj).sharedMaterial = ((Collider)piece.col).sharedMaterial;
								Object.Destroy((Object)(object)piece.col);
								piece.col = null;
							}
						}
					}
				}
				catch (Exception e5)
				{
					GoreSystem.WarnThrottled("GoreSkeleton piece tick", e5);
				}
			}
			GoreProf.End(5, t);
			for (int num10 = drippers.Count - 1; num10 >= 0; num10--)
			{
				try
				{
					DripSource dripSource = drippers[num10];
					if ((Object)(object)dripSource.cap == (Object)null || time >= dripSource.until)
					{
						drippers.RemoveAt(num10);
					}
					else if (!(time < dripSource.next))
					{
						dripSource.next = time + 0.4f / Mathf.Max(dripSource.strength, 0.5f);
						Bounds bounds2 = dripSource.cap.bounds;
						GoreSystem.Dribble(((Bounds)(ref bounds2)).center, dripSource.palette);
						if (dripSource.strength >= 2f)
						{
							bounds2 = dripSource.cap.bounds;
							GoreSystem.Dribble(((Bounds)(ref bounds2)).center, dripSource.palette);
						}
					}
				}
				catch (Exception e6)
				{
					GoreSystem.WarnThrottled("GoreSkeleton dripper tick", e6);
				}
			}
		}

		internal static string Census()
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (Corpse corpse in corpses)
			{
				if (corpse.alive)
				{
					num3++;
				}
				if (corpse.frozen)
				{
					num++;
				}
				else
				{
					num2 += corpse.rbs.Count;
				}
			}
			return $"corpses {corpses.Count} ({num} frozen, {num2} live rbs, {num3} live rigs), " + $"pieces {pieces.Count}, drippers {drippers.Count}, cutQ {cutQueue.Count}";
		}

		internal static void OnDeath(CharacterBody body, GoreSystem.Blow blow, int palette)
		{
			if (!ModOptions.TestButtons.Value)
			{
				OnDeathInner(body, blow, palette);
				return;
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			long t = GoreProf.Begin();
			try
			{
				OnDeathInner(body, blow, palette);
			}
			finally
			{
				GoreProf.End(9, t);
				stopwatch.Stop();
				if (stopwatch.ElapsedMilliseconds >= 25)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)($"[gore timing] death {((Object)body).name}: {stopwatch.ElapsedMilliseconds}ms" + $" (kind {blow.kind}, elem {blow.element})"));
				}
			}
		}

		private static void OnDeathInner(CharacterBody body, GoreSystem.Blow blow, int palette)
		{
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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)
			Transform val = (((Object)(object)body.modelLocator != (Object)null) ? body.modelLocator.modelTransform : null);
			if ((Object)(object)val == (Object)null || body.isPlayerControlled)
			{
				return;
			}
			Corpse corpse;
			if (byModel.TryGetValue(val, out var value))
			{
				if (!value.alive)
				{
					return;
				}
				PromoteLiveCorpse(value);
				corpse = value;
			}
			else
			{
				if (!TakeDeathBudget())
				{
					return;
				}
				corpse = Register(val, palette);
				if (corpse == null)
				{
					return;
				}
			}
			AdoptCorpse(body, corpse);
			ForceRagdoll(body, corpse, blow);
			LockAnimators(corpse);
			if (corpse.adopted && blow.element == 7)
			{
				SnatchModel(body);
			}
			float num = (float)blow.overkill / 64f;
			float boost = GoreSystem.OverkillBoost(blow.overkill);
			ElementStart(corpse, blow);
			switch (blow.kind)
			{
			case 2:
			{
				Vector3 dir = SlabNormal(blow.slabRot, blow.slabHalf);
				CutReq req = new CutReq
				{
					c = corpse,
					shape = 0,
					style = 0,
					pos = blow.slabPos,
					dir = dir,
					boost = boost
				};
				if (corpse.totalVerts <= 12000 && TakeInstantKillCut())
				{
					RunCutNow(corpse, req);
				}
				else
				{
					Enqueue(req);
				}
				break;
			}
			case 1:
				EnqueueBlast(corpse, blow.pos, blow.radius, 1, (num >= 2f) ? 3 : 2, boost);
				break;
			}
		}

		private static void EnqueueBlast(Corpse c, Vector3 pos, float radius, byte style, int planes, float boost)
		{
			//IL_0022: 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)
			//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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0088: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0098: 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)
			Enqueue(new CutReq
			{
				c = c,
				shape = 1,
				style = style,
				pos = pos,
				radius = radius * 0.45f,
				boost = boost
			});
			Vector3 val = RandomInSphere();
			Vector3 val2 = ((Vector3)(ref val)).normalized;
			if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
			{
				val2 = Vector3.up;
			}
			for (int i = 0; i < planes; i++)
			{
				Vector3 val3;
				if (i != 0)
				{
					val = Vector3.Cross(val2, RandomInSphere());
					val3 = ((Vector3)(ref val)).normalized;
				}
				else
				{
					val3 = val2;
				}
				Vector3 dir = val3;
				if (((Vector3)(ref dir)).sqrMagnitude < 0.01f)
				{
					dir = Vector3.right;
				}
				Vector3 val4 = RandomInSphere() * (radius * 0.2f);
				Enqueue(new CutReq
				{
					c = c,
					shape = 0,
					style = style,
					pos = pos + val4,
					dir = dir,
					boost = boost
				});
			}
		}

		internal static void OnGouge(Vector3 pos, Quaternion rot, Vector3 half)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (corpses.Count == 0)
			{
				return;
			}
			long t = GoreProf.Begin();
			Vector3 dir = SlabNormal(rot, half);
			float num = ((Vector3)(ref half)).magnitude + 1f;
			foreach (Corpse corpse in corpses)
			{
				if (!corpse.alive && !((Object)(object)corpse.modelTf == (Object)null) && !((Object)(object)corpse.refBone == (Object)null) && WithinReach(corpse, pos, num + corpse.radius))
				{
					WakeCorpse(corpse);
					ScheduleUnearthProbe(corpse);
					if (Cuttable(corpse))
					{
						Enqueue(new CutReq
						{
							c = corpse,
							shape = 0,
							style = 3,
							pos = pos,
							dir = dir
						});
					}
				}
			}
			CutPiecesNear(0, 3, pos, dir, 0f, num);
			GoreProf.End(42, t);
		}

		internal static void OnBlast(Vector3 pos, float r)
		{
			//IL_00a3: 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_005c: 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)
			if (corpses.Count == 0)
			{
				return;
			}
			long t = GoreProf.Begin();
			foreach (Corpse corpse in corpses)
			{
				if (corpse.alive || (Object)(object)corpse.modelTf == (Object)null || (Object)(object)corpse.refBone == (Object)null)
				{
					continue;
				}
				float reach = corpse.radius + r + 0.5f;
				if (WithinReach(corpse, pos, reach))
				{
					WakeCorpse(corpse);
					ScheduleUnearthProbe(corpse);
					if (Cuttable(corpse))
					{
						EnqueueBlast(corpse, pos, r, 4, 1, 1f);
					}
				}
			}
			CutPiecesNear(1, 4, pos, Vector3.up, r * 0.45f, r + 1f);
			GoreProf.End(42, t);
		}

		internal static bool IsCorpseCollider(Collider col)
		{
			if (corpses.Count == 0 || (Object)(object)col == (Object)null)
			{
				return false;
			}
			Transform val = ((Component)col).transform;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 32)
			{
				if (byModel.ContainsKey(val))
				{
					return true;
				}
				val = val.parent;
				num++;
			}
			return false;
		}

		internal static void OnBullet(Vector3 pos, Vector3 dir)
		{
			//IL_00ba: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Corpse corpse = null;
			float num = float.MaxValue;
			foreach (Corpse corpse2 in corpses)
			{
				if (!corpse2.alive && !((Object)(object)corpse2.modelTf == (Object)null) && !((Object)(object)corpse2.refBone == (Object)null))
				{
					Vector3 val = corpse2.refBone.position - pos;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					float num2 = corpse2.radius + 1f;
					if (sqrMagnitude < num2 * num2 && sqrMagnitude < num)
					{
						num = sqrMagnitude;
						corpse = corpse2;
					}
				}
			}
			if (corpse != null)
			{
				float time = Time.time;
				if (time - corpse.lastBite < 0.12f)
				{
					return;
				}
				corpse.lastBite = time;
			}
			GoreSystem.BulletSpray(pos, dir, corpse?.palette ?? 0);
		}

		private static bool WithinReach(Corpse c, Vector3 pos, float reach)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0015: 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)
			//IL_0028: 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)
			float num = reach * reach;
			Vector3 val = c.refBone.position - pos;
			if (((Vector3)(ref val)).sqrMagnitude <= num)
			{
				return true;
			}
			val = c.center - pos;
			return ((Vector3)(ref val)).sqrMagnitude <= num;
		}

		private static bool Cuttable(Corpse c)
		{
			if ((Object)(object)c.modelTf != (Object)null && (Object)(object)c.refBone != (Object)null && Time.time < c.expireAt && c.cuts < 16)
			{
				return c.queued < 5;
			}
			return false;
		}

		private static void Enqueue(CutReq req, bool force = false)
		{
			if (force || cutQueue.Count < 24)
			{
				req.c.queued++;
				cutQueue.Enqueue(req);
			}
		}

		private static void RunCutNow(Corpse c, CutReq req)
		{
			if ((Object)(object)c.modelTf == (Object)null)
			{
				return;
			}
			try
			{
				ExecuteCut(c, req);
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("GoreSkeleton instant kill-cut", e);
			}
		}

		private static bool TakeDeoptBudget()
		{
			int frameCount = Time.frameCount;
			if (frameCount == deoptFrame)
			{
				return false;
			}
			deoptFrame = frameCount;
			return true;
		}

		private static bool TakeInstantKillCut()
		{
			int frameCount = Time.frameCount;
			if (frameCount != instantKillFrame)
			{
				instantKillFrame = frameCount;
				instantKillBudget = 2;
			}
			if (instantKillBudget <= 0)
			{
				return false;
			}
			instantKillBudget--;
			return true;
		}

		internal static Vector3 SlabNormal(Quaternion rot, Vector3 half)
		{
			//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)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			return rot * (Vector3)(((!(half.x <= half.y) || !(half.x <= half.z)) ? ((half.y <= half.z) ? 1 : 2) : 0) switch
			{
				1 => Vector3.up, 
				0 => Vector3.right, 
				_ => Vector3.forward, 
			});
		}

		internal static Vector3 LongSlabAxis(Quaternion rot, Vector3 half)
		{
			//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)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			return rot * (Vector3)(((!(half.x >= half.y) || !(half.x >= half.z)) ? ((half.y >= half.z) ? 1 : 2) : 0) switch
			{
				1 => Vector3.up, 
				0 => Vector3.right, 
				_ => Vector3.forward, 
			});
		}

		private static Corpse Register(Transform modelTf, int palette)
		{
			//IL_0049: 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_0164: 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_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: 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)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			Corpse corpse = new Corpse
			{
				modelTf = modelTf,
				palette = palette
			};
			CharacterModel component = ((Component)modelTf).GetComponent<CharacterModel>();
			HashSet<SkinnedMeshRenderer> hashSet = new HashSet<SkinnedMeshRenderer>();
			List<SkinnedMeshRenderer> list = new List<SkinnedMeshRenderer>();
			if ((Object)(object)component != (Object)null && component.baseRendererInfos != null)
			{
				RendererInfo[] baseRendererInfos = component.baseRendererInfos;
				for (int i = 0; i < baseRendererInfos.Length; i++)
				{
					Renderer renderer = baseRendererInfos[i].renderer;
					SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
					if ((Object)(object)val != (Object)null && (Object)(object)val.sharedMesh != (Object)null && hashSet.Add(val))
					{
						list.Add(val);
					}
				}
			}
			else
			{
				SkinnedMeshRenderer[] componentsInChildren = ((Component)modelTf).GetComponentsInChildren<SkinnedMeshRenderer>(false);
				foreach (SkinnedMeshRenderer val2 in componentsInChildren)
				{
					if ((Object)(object)val2.sharedMesh != (Object)null && hashSet.Add(val2))
					{
						list.Add(val2);
					}
				}
			}
			foreach (SkinnedMeshRenderer item in list)
			{
				AddRend(corpse, item);
			}
			if (corpse.rends.Count == 0 && corpse.lateSmrs.Count == 0)
			{
				return null;
			}
			bool flag = false;
			Bounds val3 = default(Bounds);
			HashSet<Transform> hashSet2 = new HashSet<Transform>();
			foreach (SkinnedMeshRenderer item2 in list)
			{
				if (!flag)
				{
					val3 = ((Renderer)item2).bounds;
					flag = true;
				}
				else
				{
					((Bounds)(ref val3)).Encapsulate(((Renderer)item2).bounds);
				}
				corpse.totalVerts += item2.sharedMesh.vertexCount;
			}
			foreach (Rend rend in corpse.rends)
			{
				Transform[] bones = rend.bones;
				foreach (Transform val4 in bones)
				{
					if ((Object)(object)val4 != (Object)null && hashSet2.Add(val4))
					{
						corpse.allBones.Add(val4);
					}
				}
			}
			float num = Mathf.Max(((Bounds)(ref val3)).size.x, Mathf.Max(((Bounds)(ref val3)).size.y, ((Bounds)(ref val3)).size.z));
			if (num < 0.5f || num > 60f)
			{
				return null;
			}
			SkinnedMeshRenderer val5 = ((corpse.rends.Count > 0) ? corpse.rends[0].smr : list[0]);
			corpse.refBone = (((Object)(object)val5.rootBone != (Object)null) ? val5.rootBone : modelTf);
			corpse.center = ((Bounds)(ref val3)).center;
			corpse.boundsSize = ((Bounds)(ref val3)).size;
			Vector3 extents = ((Bounds)(ref val3)).extents;
			corpse.radius = ((Vector3)(ref extents)).magnitude;
			corpse.bornAt = Time.time;
			corpse.expireAt = Time.time + 120f;
			if (((Object)modelTf).name.Contains("Worm"))
			{
				corpse.expireAt = Time.time + 12f;
			}
			while (corpses.Count >= 48)
			{
				EvictOldest();
			}
			corpses.Add(corpse);
			byModel[modelTf] = corpse;
			return corpse;
		}

		private static void EvictOldest()
		{
			int index = 0;
			for (int i = 0; i < corpses.Count; i++)
			{
				if (!corpses[i].alive)
				{
					index = i;
					break;
				}
			}
			Corpse corpse = corpses[index];
			corpses.RemoveAt(index);
			if ((Object)(object)corpse.modelTf != (Object)null)
			{
				byModel.Remove(corpse.modelTf);
			}
			if (corpse.adopted || (Object)(object)corpse.modelTf == (Object)null)
			{
				DropOwnedMeshes(corpse);
				if (corpse.adopted && (Object)(object)corpse.modelTf != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)corpse.modelTf).gameObject);
				}
			}
			else
			{
				OrphanOwnedMeshes(corpse);
			}
		}

		private static void AddRend(Corpse c, SkinnedMeshRenderer smr)
		{
			if ((Object)(object)smr == (Object)null || (Object)(object)smr.sharedMesh == (Object)null)
			{
				return;
			}
			Transform[] bones = smr.bones;
			if (bones == null || bones.Length == 0)
			{
				Matrix4x4[] bindposes = smr.sharedMesh.bindposes;
				if (bindposes != null && bindposes.Length != 0)
				{
					c.lateSmrs.Add(smr);
				}
			}
			else
			{
				c.rends.Add(new Rend
				{
					smr = smr,
					bones = bones,
					coreVert = -1
				});
			}
		}

		private static void MaybeDeoptimize(Transform modelTf, List<SkinnedMeshRenderer> smrs)
		{
			bool flag = false;
			foreach (SkinnedMeshRenderer smr in smrs)
			{
				Transform[] bones = smr.bones;
				if (bones == null || bones.Length == 0)
				{
					Matrix4x4[] bindposes = smr.sharedMesh.bindposes;
					if (bindposes != null && bindposes.Length != 0)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				return;
			}
			try
			{
				AnimatorUtility.DeoptimizeTransformHierarchy(((Component)modelTf).gameObject);
			}
			catch (Exception ex)
			{
				if (loggedMeshes.Add(((Object)modelTf).name))
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)("GoreSkeleton: could not rebuild the optimized rig on '" + ((Object)modelTf).name + "' (" + ex.Message + "); it keeps the vanilla death."));
				}
			}
		}

		private static void ForgetOwnedMeshes(Corpse c)
		{
			foreach (Rend rend in c.rends)
			{
				rend.owned = null;
				rend.innardsMesh = null;
			}
		}

		private static void DropOwnedMeshes(Corpse c)
		{
			foreach (Rend rend in c.rends)
			{
				if ((Object)(object)rend.owned != (Object)null)
				{
					Object.Destroy((Object)(object)rend.owned);
					rend.owned = null;
				}
				if ((Object)(object)rend.innardsMesh != (Object)null)
				{
					Object.Destroy((Object)(object)rend.innardsMesh);
					rend.innardsMesh = null;
				}
			}
			foreach (FrozenSnap frozenSnap in c.frozenSnaps)
			{
				if ((Object)(object)frozenSnap.mesh != (Object)null)
				{
					Object.Destroy((Object)(object)frozenSnap.mesh);
				}
			}
			c.frozenSnaps.Clear();
		}

		private static void OrphanOwnedMeshes(Corpse c)
		{
			foreach (Rend rend in c.rends)
			{
				if ((Object)(object)rend.owned != (Object)null)
				{
					orphanedMeshes.Add(rend.owned);
					rend.owned = null;
				}
				if ((Object)(object)rend.innardsMesh != (Object)null)
				{
					orphanedMeshes.Add(rend.innardsMesh);
					rend.innardsMesh = null;
				}
			}
		}

		private static void PrepareRend(Rend rend)
		{
			if (rend.prepared)
			{
				return;
			}
			rend.prepared = true;
			rend.dead = true;
			SkinnedMeshRenderer smr = rend.smr;
			if ((Object)(object)smr == (Object)null || (Object)(object)smr.sharedMesh == (Object)null)
			{
				return;
			}
			BakedMesh baked = GetBaked(smr.sharedMesh);
			if (!baked.dead && baked.bindposes.Length == rend.bones.Length)
			{
				rend.weights = baked.weights;
				rend.bindPos = baked.pos;
				rend.bindNrm = baked.nrm;
				rend.bindposes = baked.bindposes;
				rend.bindTan = baked.tan;
				rend.bindUv = baked.uv;
				rend.bindCol = baked.col;
				rend.skinScratch = (Matrix4x4[])(object)new Matrix4x4[rend.bones.Length];
				rend.ext = new List<int>[baked.ext.Length];
				for (int i = 0; i < baked.ext.Length; i++)
				{
					rend.ext[i] = new List<int>(baked.ext[i]);
				}
				rend.canon = baked.canon;
				rend.baseVerts = baked.pos.Length;
				rend.boneAcc = baked.boneAcc;
				rend.domBone = baked.domBone;
				rend.domCoreVert = baked.domCoreVert;
				rend.dead = false;
			}
		}

		private static int[] BuildCanon(Vector3[] pos, int count)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			int[] array = new int[count];
			Dictionary<Vector3, int> dictionary = new Dictionary<Vector3, int>(count);
			for (int i = 0; i < count; i++)
			{
				int num = i;
				int num4;
				if (!dictionary.TryGetValue(pos[i], out var value))
				{
					int num2 = (dictionary[pos[i]] = i);
					num4 = num2;
				}
				else
				{
					num4 = value;
				}
				array[num] = num4;
			}
			return array;
		}

		private static int[] BuildCanon(List<Vector3> pos, int count)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			int[] array = new int[count];
			Dictionary<Vector3, int> dictionary = new Dictionary<Vector3, int>(count);
			for (int i = 0; i < count; i++)
			{
				int num = i;
				int num4;
				if (!dictionary.TryGetValue(pos[i], out var value))
				{
					int num2 = (dictionary[pos[i]] = i);
					num4 = num2;
				}
				else
				{
					num4 = value;
				}
				array[num] = num4;
			}
			return array;
		}

		private static List<int> BoundaryEdges(List<int>[] tris, int[] canon)
		{
			Dictionary<long, int> dictionary = edgeCountScratch ?? (edgeCountScratch = new Dictionary<long, int>(32768, EdgeKeyComparer.Instance));
			Dictionary<long, (int, int)> dictionary2 = edgeReprScratch ?? (edgeReprScratch = new Dictionary<long, (int, int)>(32768, EdgeKeyComparer.Instance));
			dictionary.Clear();
			dictionary2.Clear();
			foreach (List<int> list in tris)
			{
				for (int j = 0; j + 2 < list.Count; j += 3)
				{
					for (int k = 0; k < 3; k++)
					{
						int num = list[j + k];
						int num2 = list[j + (k + 1) % 3];
						int num3 = C(num);
						int num4 = C(num2);
						if (num3 != num4)
						{
							long key = ((num3 < num4) ? (((long)num3 << 32) | (uint)num4) : (((long)num4 << 32) | (uint)num3));
							dictionary.TryGetValue(key, out var value);
							dictionary[key] = value + 1;
							if (value == 0)
							{
								dictionary2[key] = (num, num2);
							}
						}
					}
				}
			}
			List<int> list2 = new List<int>();
			foreach (KeyValuePair<long, int> item3 in dictionary)
			{
				if (item3.Value == 1)
				{
					var (item, item2) = dictionary2[item3.Key];
					list2.Add(item);
					list2.Add(item2);
				}
			}
			return list2;
			int C(int x)
			{
				if (canon == null || x >= canon.Length)
				{
					return x;
				}
				return canon[x];
			}
		}

		private static void EnsureCore(Corpse c)
		{
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			if (c.coreReady)
			{
				return;
			}
			c.coreReady = true;
			Dictionary<Transform, float> dictionary = new Dictionary<Transform, float>();
			foreach (Rend rend in c.rends)
			{
				if (rend.dead || rend.weights == null || rend.boneAcc == null)
				{
					continue;
				}
				Transform[] bones = rend.bones;
				float[] boneAcc = rend.boneAcc;
				int num = Math.Min(boneAcc.Length, bones.Length);
				for (int i = 0; i < num; i++)
				{
					if (!(boneAcc[i] <= 0f) && !((Object)(object)bones[i] == (Object)null))
					{
						dictionary.TryGetValue(bones[i], out var value);
						dictionary[bones[i]] = value + boneAcc[i];
					}
				}
			}
			float num2 = 0f;
			foreach (KeyValuePair<Transform, float> item in dictionary)
			{
				if (item.Value > num2)
				{
					num2 = item.Value;
					c.coreBone = item.Key;
				}
			}
			if ((Object)(object)c.coreBone == (Object)null)
			{
				c.coreBone = c.refBone;
			}
			foreach (Rend rend2 in c.rends)
			{
				if (rend2.dead || rend2.weights == null)
				{
					continue;
				}
				int num3 = Array.IndexOf(rend2.bones, c.coreBone);
				if (num3 < 0)
				{
					continue;
				}
				if (num3 == rend2.domBone && rend2.domCoreVert >= 0)
				{
					rend2.coreVert = rend2.domCoreVert;
					continue;
				}
				float num4 = 0f;
				for (int j = 0; j < rend2.weights.Length; j++)
				{
					BoneWeight val = rend2.weights[j];
					float num5 = 0f;
					if (((BoneWeight)(ref val)).boneIndex0 == num3)
					{
						num5 += ((BoneWeight)(ref val)).weight0;
					}
					if (((BoneWeight)(ref val)).boneIndex1 == num3)
					{
						num5 += ((BoneWeight)(ref val)).weight1;
					}
					if (((BoneWeight)(ref val)).boneIndex2 == num3)
					{
						num5 += ((BoneWeight)(ref val)).weight2;
					}
					if (((BoneWeight)(ref val)).boneIndex3 == num3)
					{
						num5 += ((BoneWeight)(ref val)).weight3;
					}
					if (num5 > num4)
					{
						num4 = num5;
						rend2.coreVert = j;
						if (num5 > 0.75f)
						{
							break;
						}
					}
				}
			}
		}

		private static void MarkSeveredBones(Corpse c, CutReq req)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform allBone in c.allBones)
			{
				if (!((Object)(object)allBone == (Object)null) && !c.sweepBones.Contains(allBone))
				{
					bool num;
					if (req.shape != 0)
					{
						Vector3 val = allBone.position - req.pos;
						num = ((Vector3)(ref val)).magnitude < req.radius;
					}
					else
					{
						num = Vector3.Dot(allBone.position - req.pos, req.dir) < 0f;
					}
					if (num)
					{
						c.sweepBones.Add(allBone);
						GoreWounds.DropOn(allBone);
					}
				}
			}
			c.sweepUntil = Time.time + 2.5f;
			SweepSeveredColliders(c);
		}

		private static void SweepSeveredColliders(Corpse c)
		{
			foreach (Transform sweepBone in c.sweepBones)
			{
				if ((Object)(object)sweepBone == (Object)null)
				{
					continue;
				}
				((Component)sweepBone).GetComponents<Collider>(colliderBuf);
				foreach (Collider item in colliderBuf)
				{
					if ((Object)(object)item != (Object)null && item.enabled)
					{
						item.enabled = false;
					}
				}
			}
			colliderBuf.Clear();
		}

		private static Vector3 RandomInSphere()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			for (int i = 0; i < 8; i++)
			{
				((Vector3)(ref result))..ctor((float)rng.NextDouble() * 2f - 1f, (float)rng.NextDouble() * 2f - 1f, (float)rng.NextDouble() * 2f - 1f);
				if (((Vector3)(ref result)).sqrMagnitude <= 1f)
				{
					return result;
				}
			}
			return Vector3.up;
		}

		private static void EnsureDeopt(Corpse c)
		{
			if (c.alive || c.deoptDone || c.lateSmrs.Count == 0)
			{
				return;
			}
			c.deoptDone = true;
			MaybeDeoptimize(c.modelTf, c.lateSmrs);
			HashSet<Transform> hashSet = new HashSet<Transform>(c.allBones);
			bool flag = false;
			foreach (SkinnedMeshRenderer lateSmr in c.lateSmrs)
			{
				if ((Object)(object)lateSmr == (Object)null || (Object)(object)lateSmr.sharedMesh == (Object)null)
				{
					continue;
				}
				Transform[] bones = lateSmr.bones;
				if (bones == null || bones.Length == 0)
				{
					continue;
				}
				c.rends.Add(new Rend
				{
					smr = lateSmr,
					bones = bones,
					coreVert = -1
				});
				flag = true;
				Transform[] array = bones;
				foreach (Transform val in array)
				{
					if ((Object)(object)val != (Object)null && hashSet.Add(val))
					{
						c.allBones.Add(val);
					}
				}
			}
			c.lateSmrs.Clear();
			if (flag)
			{
				c.coreReady = false;
			}
		}

		private static double PhaseMs(long ticks)
		{
			return (double)ticks * 1000.0 / (double)Stopwatch.Frequency;
		}

		private static void ExecuteCut(Corpse c, CutReq req)
		{
			//IL_008f: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (c.cutBusy)
			{
				Enqueue(req, force: true);
				return;
			}
			long timestamp = Stopwatch.GetTimestamp();
			WakeCorpse(c);
			ScheduleUnearthProbe(c);
			EnsureDeopt(c);
			long timestamp2 = Stopwatch.GetTimestamp();
			foreach (Rend rend in c.rends)
			{
				PrepareRend(rend);
			}
			EnsureCore(c);
			long timestamp3 = Stopwatch.GetTimestamp();
			Vector3 val = (((Object)(object)c.coreBone != (Object)null) ? c.coreBone.position : c.refBone.position);
			if (req.shape == 0)
			{
				if (Vector3.Dot(val - req.pos, req.dir) < 0f)
				{
					req.dir = -req.dir;
				}
			}
			else if (req.style == 1 || req.style == 4 || req.style == 7 || req.style == 8)
			{
				req.radius = Mathf.Min(req.radius, c.radius * 0.35f);
			}
			CutJob cutJob = new CutJob
			{
				c = c,
				req = req,
				alive = c.alive,
				wantFlesh = ((Object)(object)GoreSystem.FleshMaterial(c.palette) != (Object)null),
				wantBone = ((Object)(object)GoreSystem.BoneMaterial(c.palette) != (Object)null)
			};
			foreach (Rend rend2 in c.rends)
			{
				if (rend2.dead)
				{
					continue;
				}
				try
				{
					RendCut rendCut = CaptureRendCut(c, rend2, req);
					if (rendCut != null)
					{
						cutJob.rends.Add(rendCut);
					}
				}
				catch (Exception arg)
				{
					rend2.dead = true;
					ManualLogSource log = ScorchedVoxelsPlugin.Log;
					SkinnedMeshRenderer smr = rend2.smr;
					log.LogWarning((object)$"GoreSkeleton capture failed on '{((smr != null) ? ((Object)smr).name : null)}': {arg}");
				}
			}
			if (cutJob.rends.Count == 0)
			{
				return;
			}
			c.cutBusy = true;
			long timestamp4 = Stopwatch.GetTimestamp();
			SubmitJob(cutJob);
			if (ModOptions.TestButtons.Value)
			{
				long timestamp5 = Stopwatch.GetTimestamp();
				if (PhaseMs(timestamp5 - timestamp) >= 25.0)
				{
					ManualLogSource log2 = ScorchedVoxelsPlugin.Log;
					string[] array = new string[6];
					Transform modelTf = c.modelTf;
					array[0] = $"[gore timing] capture {((modelTf != null) ? ((Object)modelTf).name : null)}: {PhaseMs(timestamp5 - timestamp):F1}ms";
					array[1] = $" — wake/deopt {PhaseMs(timestamp2 - timestamp):F1}";
					array[2] = $" prepare/core {PhaseMs(timestamp3 - timestamp2):F1}";
					array[3] = $" rends {PhaseMs(timestamp4 - timestamp3):F1}";
					array[4] = $" submit {PhaseMs(timestamp5 - timestamp4):F1}";
					array[5] = $" ({c.rends.Count} rends, cut #{c.cuts})";
					log2.LogInfo((object)string.Concat(array));
				}
			}
		}

		private static RendCut CaptureRendCut(Corpse c, Rend rend, CutReq req)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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_0111: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_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)
			SkinnedMeshRenderer smr = rend.smr;
			if ((Object)(object)smr == (Object)null)
			{
				return null;
			}
			Mesh sharedMesh = smr.sharedMesh;
			if ((Object)(object)sharedMesh == (Object)null || sharedMesh.vertexCount != rend.weights.Length)
			{
				return null;
			}
			int vertexCount = sharedMesh.vertexCount;
			if (rend.baseVerts > 0 && vertexCount >= rend.baseVerts * 3 + 2000)
			{
				return null;
			}
			if (c.rends.Count > 1)
			{
				Bounds bounds = ((Renderer)smr).bounds;
				Vector3 extents = ((Bounds)(ref bounds)).extents;
				float num = 0.25f * ((Vector3)(ref extents)).magnitude + 0.5f;
				if (req.shape == 1)
				{
					float num2 = req.radius + num;
					if (((Bounds)(ref bounds)).SqrDistance(req.pos) > num2 * num2)
					{
						return null;
					}
				}
				else
				{
					Vector3 extents2 = ((Bounds)(ref bounds)).extents;
					float num3 = Mathf.Abs(req.dir.x) * extents2.x + Mathf.Abs(req.dir.y) * extents2.y + Mathf.Abs(req.dir.z) * extents2.z;
					if (Vector3.Dot(((Bounds)(ref bounds)).center - req.pos, req.dir) - num3 - num > 0f)
					{
						return null;
					}
				}
			}
			return new RendCut
			{
				rend = rend,
				n = vertexCount,
				skin = BuildSkinMatrices(rend),
				boneSpots = ((req.shape == 1) ? null : BoneCrossings(rend, req.pos, req.dir)),
				meshName = ((Object)sharedMesh).name,
				meshBounds = sharedMesh.bounds
			};
		}

		private static void ComputeCutJob(CutJob job)
		{
			long timestamp = Stopwatch.GetTimestamp();
			bool flag = false;
			foreach (RendCut rend in job.rends)
			{
				try
				{
					flag |= ComputeRendCut(job, rend);
				}
				catch (Exception error)
				{
					rend.cutHappened = false;
					rend.computeThrew = true;
					if (job.error == null)
					{
						job.error = error;
					}
				}
			}
			if (flag && job.geos.Count > 0)
			{
				long timestamp2 = Stopwatch.GetTimestamp();
				job.geos.Sort((PieceGeo a, PieceGeo b) => b.pos.Count.CompareTo(a.pos.Count));
				for (int num = 0; num < job.geos.Count && num < 6; num++)
				{
					job.preps.Add(PrepPiece(job, job.geos[num]));
				}
				job.phPieces += Stopwatch.GetTimestamp() - timestamp2;
			}
			job.computeTicks = Stopwatch.GetTimestamp() - timestamp;
		}

		private static bool ComputeRendCut(CutJob job, RendCut cap)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			Rend rend = cap.rend;
			CutReq req = job.req;
			int n = cap.n;
			long timestamp = Stopwatch.GetTimestamp();
			Vector3[] array = (Vector3[])(object)new Vector3[n];
			Vector3[] wn = (Vector3[])(object)((rend.bindNrm != null) ? new Vector3[n] : null);
			SkinPoints(rend, cap.skin, array, wn);
			float[] array2 = new float[n];
			if (req.shape == 0)
			{
				for (int i = 0; i < n; i++)
				{
					float num = Vector3.Dot(array[i] - req.pos, req.dir);
					array2[i] = ((Mathf.Abs(num) < 0.0001f) ? 0.0001f : num);
				}
			}
			else
			{
				for (int j = 0; j < n; j++)
				{
					Vector3 val = array[j] - req.pos;
					float num2 = ((Vector3)(ref val)).magnitude - req.radius;
					array2[j] = ((Mathf.Abs(num2) < 0.0001f) ? 0.0001f : num2);
				}
			}
			job.phSkin += Stopwatch.GetTimestamp() - timestamp;
			int num3 = rend.ext.Length;
			List<int>[] array3 = new List<int>[num3];
			List<int>[] array4 = new List<int>[num3];
			for (int k = 0; k < num3; k++)
			{
				array3[k] = new List<int>(rend.ext[k].Count);
				array4[k] = new List<int>();
			}
			SplitVerts splitVerts = new SplitVerts(rend, array, wn);
			bool flag = req.shape == 1;
			List<int>[] array5 = null;
			if (flag && job.alive)
			{
				array5 = new List<int>[num3];
				for (int l = 0; l < num3; l++)
				{
					array5[l] = new List<int>();
				}
			}
			timestamp = Stopwatch.GetTimestamp();
			GoreCutCore.Classify(array2, rend.ext, flag, splitVerts.At, array3, array4, out var dropped, array5);
			job.phClassify += Stopwatch.GetTimestamp() - timestamp;
			if (flag && !dropped)
			{
				return false;
			}
			bool flag2 = false;
			List<int>[] array6 = array4;
			foreach (List<int> list in array6)
			{
				flag2 |= list.Count > 0;
			}
			if (!flag2 && !dropped)
			{
				return false;
			}
			if (flag && flag2)
			{
				if (job.alive)
				{
					for (int num4 = 0; num4 < array4.Length; num4++)
					{
						array3[num4].AddRange(array4[num4]);
						array4[num4].Clear();
					}
					flag2 = false;
				}
				else
				{
					GoreCutCore.SphereKeep(array4, array3, rend.coreVert, n, rend.canon);
					flag2 = false;
					array6 = array4;
					foreach (List<int> list2 in array6)
					{
						flag2 |= list2.Count > 0;
					}
				}
			}
			timestamp = Stopwatch.GetTimestamp();
			if (flag2)
			{
				int count = job.geos.Count;
				List<List<int>[]> comps = GoreCutCore.Components(array4, n + splitVerts.Count, rend.canon);
				BuildGeos(rend, comps, array3, splitVerts, array, wn, job.geos);
				for (int num5 = count; num5 < job.geos.Count; num5++)
				{
					job.geos[num5].boneSpots = cap.boneSpots;
				}
			}
			if (array5 != null && dropped)
			{
				BuildBiteGeo(rend, array5, splitVerts, array, wn, job.geos);
			}
			job.phGeo += Stopwatch.GetTimestamp() - timestamp;
			timestamp = Stopwatch.GetTimestamp();
			RebuildRemainderCompute(cap, rend, array3, splitVerts);
			job.phRebuild += Stopwatch.GetTimestamp() - timestamp;
			cap.wv = array;
			cap.farT = array4;
			cap.split = splitVerts;
			cap.dropped = dropped;
			cap.cutHappened = true;
			return true;
		}

		private static void ApplyCutJob(CutJob job)
		{
			Corpse c = job.c;
			try
			{
				if (job.error != null)
				{
					GoreSystem.WarnThrottled("GoreSkeleton cut", job.error);
				}
				if ((Object)(object)c.modelTf == (Object)null || !byModel.TryGetValue(c.modelTf, out var value) || value != c)
				{
					return;
				}
				long timestamp = Stopwatch.GetTimestamp();
				int num = GC.CollectionCount(0);
				bool flag = false;
				HashSet<Rend> hashSet = null;
				foreach (RendCut rend in job.rends)
				{
					if (rend.computeThrew)
					{
						rend.rend.dead = true;
					}
					else
					{
						if (!rend.cutHappened)
						{
							continue;
						}
						try
						{
							if (ApplyRendCut(job, rend))
							{
								flag = true;
								(hashSet ?? (hashSet = new HashSet<Rend>())).Add(rend.rend);
							}
						}
						catch (Exception arg)
						{
							rend.rend.dead = true;
							ManualLogSource log = ScorchedVoxelsPlugin.Log;
							SkinnedMeshRenderer smr = rend.rend.smr;
							log.LogWarning((object)$"GoreSkeleton apply failed on '{((smr != null) ? ((Object)smr).name : null)}': {arg}");
						}
					}
				}
				if (!flag)
				{
					return;
				}
				int num2 = 0;
				foreach (PiecePrep prep in job.preps)
				{
					if (num2 >= 6)
					{
						break;
					}
					if (hashSet.Contains(prep.geo.rend))
					{
						long t = GoreProf.Begin();
						if (SpawnPiecePrepared(c, prep, job.req))
						{
							num2++;
						}
						GoreProf.End(8, t);
					}
				}
				if (num2 > 0 && !job.alive)
				{
					MarkSeveredBones(c, job.req);
				}
				c.cuts++;
				StopStarvedEmitters(c);
				if (!ModOptions.TestButtons.Value)
				{
					return;
				}
				double num3 = PhaseMs(job.computeTicks);
				double num4 = PhaseMs(Stopwatch.GetTimestamp() - timestamp);
				if (num4 >= 15.0 || num3 >= 25.0)
				{
					ManualLogSource log2 = ScorchedVoxelsPlugin.Log;
					string[] obj = new string[9] { "[gore timing] cut ", null, null, null, null, null, null, null, null };
					Transform modelTf = c.modelTf;
					obj[1] = ((modelTf != null) ? ((Object)modelTf).name : null);
					obj[2] = ":";
					obj[3] = $" apply {num4:F1}ms + compute {num3:F1}ms off-thread";
					obj[4] = $" (shape {job.req.shape}, style {job.req.style}, cut #{c.cuts})";
					obj[5] = $" — skin {PhaseMs(job.phSkin):F1} classify {PhaseMs(job.phClassify):F1}";
					obj[6] = $" geo {PhaseMs(job.phGeo):F1} rebuild {PhaseMs(job.phRebuild):F1}";
					obj[7] = $" pieces {PhaseMs(job.phPieces):F1},";
					obj[8] = $" gc0 +{GC.CollectionCount(0) - num}";
					log2.LogInfo((object)string.Concat(obj));
					if (job.ppTris > 0)
					{
						ManualLogSource log3 = ScorchedVoxelsPlugin.Log;
						string[] obj2 = new string[5] { "[gore timing] pieces ", null, null, null, null };
						Transform modelTf2 = c.modelTf;
						obj2[1] = ((modelTf2 != null) ? ((Object)modelTf2).name : null);
						obj2[2] = ":";
						obj2[3] = $" edges {PhaseMs(job.ppEdges):F1} shell {PhaseMs(job.ppShell):F1}";
						obj2[4] = $" off-thread ({job.preps.Count} prepped, tris {job.ppTris})";
						log3.LogInfo((object)string.Concat(obj2));
					}
				}
			}
			finally
			{
				c.cutBusy = false;
			}
		}

		private static bool ApplyRendCut(CutJob job, RendCut cap)
		{
			//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_008a: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			Rend rend = cap.rend;
			if (rend.dead || (Object)(object)rend.smr == (Object)null)
			{
				return false;
			}
			Mesh sharedMesh = rend.smr.sharedMesh;
			if ((Object)(object)sharedMesh == (Object)null || sharedMesh.vertexCount != cap.n)
			{
				return false;
			}
			Mesh val = rend.owned;
			if ((Object)(object)val == (Object)null)
			{
				val = new Mesh
				{
					name = (cap.meshName.EndsWith("_cut") ? cap.meshName : (cap.meshName + "_cut"))
				};
				val.MarkDynamic();
			}
			else
			{
				val.Clear();
			}
			val.indexFormat = (IndexFormat)(cap.newPos.Length > 65535);
			val.vertices = cap.newPos;
			if (cap.newNrm != null)
			{
				val.normals = cap.newNrm;
			}
			if (cap.newTan != null)
			{
				val.tangents = cap.newTan;
			}
			if (cap.newUv != null)
			{
				val.uv = cap.newUv;
			}
			if (cap.newCol != null)
			{
				val.colors32 = cap.newCol;
			}
			ApplySkinWeightsFlat(val, cap.bwPerVert, cap.bwFlat, cap.bwFlatCount);
			val.bindposes = rend.bindposes;
			val.subMeshCount = cap.coreT.Length;
			for (int i = 0; i < cap.coreT.Length; i++)
			{
				val.SetTriangles(cap.coreT[i], i, false, 0);
			}
			val.bounds = cap.meshBounds;
			rend.weights = cap.newWeights;
			rend.bindPos = cap.newPos;
			rend.bindNrm = cap.newNrm;
			rend.bindTan = cap.newTan;
			rend.bindUv = cap.newUv;
			rend.bindCol = cap.newCol;
			if (cap.newCanon != null)
			{
				rend.canon = cap.newCanon;
			}
			rend.ext = cap.coreT;
			rend.smr.sharedMesh = null;
			rend.smr.sharedMesh = val;
			rend.owned = val;
			MarkInnards(job.c, rend, cap.boneSpots);
			if (RecordCuts)
			{
				RecordCut(job.c, rend, job.req, cap.wv, cap.coreT, cap.farT, cap.split, cap.dropped);
			}
			return true;
		}

		private static List<Vector3> BoneCrossings(Rend rend, Vector3 pos, Vector3 dir)
		{
			//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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00a1: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Transform[] bones = rend.bones;
			HashSet<Transform> hashSet = new HashSet<Transform>();
			Transform[] array = bones;
			foreach (Transform val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					hashSet.Add(val);
				}
			}
			array = bones;
			foreach (Transform val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.parent == (Object)null) && hashSet.Contains(val2.parent))
				{
					Vector3 position = val2.position;
					Vector3 position2 = val2.parent.position;
					float num = Vector3.Dot(position - pos, dir);
					float num2 = Vector3.Dot(position2 - pos, dir);
					if (!(num * num2 >= 0f))
					{
						list.Add(Vector3.LerpUnclamped(position, position2, num / (num - num2)));
					}
				}
			}
			return list;
		}

		private static Matrix4x4[] BuildSkinMatrices(Rend rend)
		{
			//IL_003c: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			Transform[] bones = rend.bones;
			Matrix4x4[] bindposes = rend.bindposes;
			Matrix4x4[] array = rend.skinScratch ?? (rend.skinScratch = (Matrix4x4[])(object)new Matrix4x4[bones.Length]);
			Matrix4x4 localToWorldMatrix = ((Component)rend.smr).transform.localToWorldMatrix;
			for (int i = 0; i < bones.Length; i++)
			{
				array[i] = (((Object)(object)bones[i] != (Object)null) ? (bones[i].localToWorldMatrix * bindposes[i]) : localToWorldMatrix);
			}
			return array;
		}

		private static void SkinPoints(Rend rend, Matrix4x4[] skin, Vector3[] wv, Vector3[] wn)
		{
			//IL_001e: 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)
			//IL_0027: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			BoneWeight[] weights = rend.weights;
			Vector3[] bindPos = rend.bindPos;
			Vector3[] bindNrm = rend.bindNrm;
			for (int i = 0; i < wv.Length; i++)
			{
				BoneWeight val = weights[i];
				Vector3 val2 = bindPos[i];
				Vector3 acc = Vector3.zero;
				float total = 0f;
				int dom = 0;
				float domW = 0f;
				AccumSkin(skin, ((BoneWeight)(ref val)).boneIndex0, ((BoneWeight)(ref val)).weight0, val2, ref acc, ref total, ref dom, ref domW);
				AccumSkin(skin, ((BoneWeight)(ref val)).boneIndex1, ((BoneWeight)(ref val)).weight1, val2, ref acc, ref total, ref dom, ref domW);
				AccumSkin(skin, ((BoneWeight)(ref val)).boneIndex2, ((BoneWeight)(ref val)).weight2, val2, ref acc, ref total, ref dom, ref domW);
				AccumSkin(skin, ((BoneWeight)(ref val)).boneIndex3, ((BoneWeight)(ref val)).weight3, val2, ref acc, ref total, ref dom, ref domW);
				wv[i] = ((total > 0.001f) ? (acc / total) : ((Matrix4x4)(ref skin[0])).MultiplyPoint3x4(val2));
				if (wn != null)
				{
					int num = i;
					Vector3 val3 = ((Matrix4x4)(ref skin[dom])).MultiplyVector(bindNrm[i]);
					wn[num] = ((Vector3)(ref val3)).normalized;
				}
			}
		}

		private static void AccumSkin(Matrix4x4[] skin, int idx, float weight, Vector3 p, ref Vector3 acc, ref float total, ref int dom, ref float domW)
		{
			//IL_0017: 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)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!(weight <= 0f) && idx >= 0 && idx < skin.Length)
			{
				acc += ((Matrix4x4)(ref skin[idx])).MultiplyPoint3x4(p) * weight;
				total += weight;
				if (weight > domW)
				{
					domW = weight;
					dom = idx;
				}
			}
		}

		private static void BuildBiteGeo(Rend rend, List<int>[] biteT, SplitVerts split, Vector3[] wv, Vector3[] wn, List<PieceGeo> geos)
		{
			//IL_0025: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Vector2[] bindUv = rend.bindUv;
			bool flag = bindUv != null && bindUv.Length == wv.Length;
			int n = wv.Length;
			HashSet<int> hashSet = new HashSet<int>();
			bool flag2 = false;
			Bounds val = default(Bounds);
			for (int i = 0; i < biteT.Length; i++)
			{
				foreach (int item in biteT[i])
				{
					if (hashSet.Add(item))
					{
						Vector3 val2 = wv[item];
						if (!flag2)
						{
							val = new Bounds(val2, Vector3.zero);
							flag2 = true;
						}
						else
						{
							((Bounds)(ref val)).Encapsulate(val2);
						}
					}
				}
			}
			if (hashSet.Count < 12 || !flag2)
			{
				return;
			}
			Vector3 size = ((Bounds)(ref val)).size;
			if (((Vector3)(ref size)).magnitude < 0.08f)
			{
				return;
			}
			PieceGeo pieceGeo = new PieceGeo
			{
				rend = rend,
				tris = new List<int>[biteT.Length]
			};
			for (int j = 0; j < biteT.Length; j++)
			{
				List<int> list = biteT[j];
				pieceGeo.tris[j] = new List<int>(list.Count);
				for (int k = 0; k + 2 < list.Count; k += 3)
				{
					pieceGeo.tris[j].Add(MapVert(pieceGeo, list[k], n, wv, wn, flag ? bindUv : null, split));
					pieceGeo.tris[j].Add(MapVert(pieceGeo, list[k + 1], n, wv, wn, flag ? bindUv : null, split));
					pieceGeo.tris[j].Add(MapVert(pieceGeo, list[k + 2], n, wv, wn, flag ? bindUv : null, split));
				}
			}
			geos.Add(pieceGeo);
		}

		private static void BuildGeos(Rend rend, List<List<int>[]> comps, List<int>[] coreT, SplitVerts split, Vector3[] wv, Vector3[] wn, List<PieceGeo> geos)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_0095: 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)
			Vector2[] bindUv = rend.bindUv;
			bool flag = bindUv != null && bindUv.Length == wv.Length;
			int num = wv.Length;
			HashSet<int> hashSet = new HashSet<int>();
			foreach (List<int>[] comp in comps)
			{
				hashSet.Clear();
				bool flag2 = false;
				Bounds val = default(Bounds);
				List<int>[] array = comp;
				for (int i = 0; i < array.Length; i++)
				{
					foreach (int item4 in array[i])
					{
						if (hashSet.Add(item4))
						{
							Vector3 val2 = ((item4 < num) ? wv[item4] : split.WorldPos(item4 - num));
							if (!flag2)
							{
								val = new Bounds(val2, Vector3.zero);
								flag2 = true;
							}
							else
							{
								((Bounds)(ref val)).Encapsulate(val2);
							}
						}
					}
				}
				if (hashSet.Count >= 12 && flag2)
				{
					Vector3 size = ((Bounds)(ref val)).size;
					if (!(((Vector3)(ref size)).magnitude < 0.08f))
					{
						PieceGeo pieceGeo = new PieceGeo
						{
							rend = rend,
							tris = new List<int>[comp.Length]
						};
						for (int j = 0; j < comp.Length; j++)
						{
							List<int> list = comp[j];
							pieceGeo.tris[j] = new List<int>(list.Count);
							for (int k = 0; k + 2 < list.Count; k += 3)
							{
								int gi = list[k];
								int gi2 = list[k + 1];
								int gi3 = list[k + 2];
								int item = MapVert(pieceGeo, gi, num, wv, wn, flag ? bindUv : null, split);
								int item2 = MapVert(pieceGeo, gi2, num, wv, wn, flag ? bindUv : null, split);
								int item3 = MapVert(pieceGeo, gi3, num, wv, wn, flag ? bindUv : null, split);
								pieceGeo.tris[j].Add(item);
								pieceGeo.tris[j].Add(item2);
								pieceGeo.tris[j].Add(item3);
							}
						}
						geos.Add(pieceGeo);
						continue;
					}
				}
				for (int l = 0; l < comp.Length; l++)
				{
					coreT[l].AddRange(comp[l]);
				}
			}
		}

		private static int MapVert(PieceGeo geo, int gi, int n, Vector3[] wv, Vector3[] wn, Vector2[] srcUv, SplitVerts split)
		{
			//IL_0018: 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_0077: 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_008f: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (geo.map.TryGetValue(gi, out var value))
			{
				return value;
			}
			Vector3 p;
			Vector3 n2;
			Vector2 u;
			if (gi < n)
			{
				p = wv[gi];
				n2 = ((wn != null) ? wn[gi] : Vector3.up);
				u = ((srcUv != null) ? srcUv[gi] : Vector2.zero);
			}
			else
			{
				split.World(gi - n, out p, out n2, out u);
			}
			value = geo.pos.Count;
			geo.map[gi] = value;
			geo.pos.Add(p);
			geo.nrm.Add(n2);
			geo.uv.Add(u);
			if (!geo.hasBounds)
			{
				geo.bounds = new Bounds(p, Vector3.zero);
				geo.hasBounds = true;
			}
			else
			{
				((Bounds)(ref geo.bounds)).Encapsulate(p);
			}
			return value;
		}

		private static BoneWeight MergeWeights(BoneWeight a, BoneWeight b, float s)
		{
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			int[] array = mergeIdx ?? (mergeIdx = new int[8]);
			float[] array2 = mergeWgt ?? (mergeWgt = new float[8]);
			Array.Clear(array, 0, 8);
			Array.Clear(array2, 0, 8);
			int count = 0;
			float num = 1f - s;
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref a)).boneIndex0, ((BoneWeight)(ref a)).weight0 * num);
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref a)).boneIndex1, ((BoneWeight)(ref a)).weight1 * num);
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref a)).boneIndex2, ((BoneWeight)(ref a)).weight2 * num);
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref a)).boneIndex3, ((BoneWeight)(ref a)).weight3 * num);
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref b)).boneIndex0, ((BoneWeight)(ref b)).weight0 * s);
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref b)).boneIndex1, ((BoneWeight)(ref b)).weight1 * s);
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref b)).boneIndex2, ((BoneWeight)(ref b)).weight2 * s);
			AddInfluence(array, array2, ref count, ((BoneWeight)(ref b)).boneIndex3, ((BoneWeight)(ref b)).weight3 * s);
			for (int i = 0; i < count && i < 4; i++)
			{
				int num2 = i;
				for (int j = i + 1; j < count; j++)
				{
					if (array2[j] > array2[num2])
					{
						num2 = j;
					}
				}
				ref float reference = ref array2[i];
				ref float reference2 = ref array2[num2];
				float num3 = array2[num2];
				float num4 = array2[i];
				reference = num3;
				reference2 = num4;
				ref int reference3 = ref array[i];
				ref int reference4 = ref array[num2];
				int num5 = array[num2];
				int num6 = array[i];
				reference3 = num5;
				reference4 = num6;
			}
			int num7 = Mathf.Min(count, 4);
			float num8 = 0f;
			for (int k = 0; k < num7; k++)
			{
				num8 += array2[k];
			}
			if (num8 <= 0f)
			{
				num7 = 1;
				array2[0] = 1f;
				num8 = 1f;
				if (count == 0)
				{
					array[0] = 0;
				}
			}
			BoneWeight result = default(BoneWeight);
			if (num7 > 0)
			{
				((BoneWeight)(ref result)).boneIndex0 = array[0];
				((BoneWeight)(ref result)).weight0 = array2[0] / num8;
			}
			if (num7 > 1)
			{
				((BoneWeight)(ref result)).boneIndex1 = array[1];
				((BoneWeight)(ref result)).weight1 = array2[1] / num8;
			}
			if (num7 > 2)
			{
				((BoneWeight)(ref result)).boneIndex2 = array[2];
				((BoneWeight)(ref result)).weight2 = array2[2] / num8;
			}
			if (num7 > 3)
			{
				((BoneWeight)(ref result)).boneIndex3 = array[3];
				((BoneWeight)(ref result)).weight3 = array2[3] / num8;
			}
			return result;
		}

		private static void AddInfluence(int[] idx, float[] wgt, ref int count, int bone, float w)
		{
			if (w <= 0f)
			{
				return;
			}
			for (int i = 0; i < count; i++)
			{
				if (idx[i] == bone)
				{
					wgt[i] += w;
					return;
				}
			}
			idx[count] = bone;
			wgt[count] = w;
			count++;
		}

		private static void RebuildRemainderCompute(RendCut cap, Rend rend, List<int>[] coreT, SplitVerts split)
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			int n = cap.n;
			int count = split.Count;
			cap.newPos = Concat(rend.bindPos, split.pos);
			cap.newNrm = ((rend.bindNrm != null) ? Concat(rend.bindNrm, split.nrm) : null);
			Vector4[] array = ((rend.bindTan != null && split.HasTan) ? Concat(rend.bindTan, split.tan) : rend.bindTan);
			cap.newTan = ((array != null && array.Length == n + count) ? array : null);
			Vector2[] array2 = ((rend.bindUv != null && split.HasUv) ? Concat(rend.bindUv, split.uv) : rend.bindUv);
			cap.newUv = ((array2 != null && array2.Length == n + count) ? array2 : null);
			Color32[] array3 = ((rend.bindCol != null && split.HasCol) ? Concat(rend.bindCol, split.col) : rend.bindCol);
			cap.newCol = ((array3 != null && array3.Length == n + count) ? array3 : null);
			BoneWeight[] weights = (BoneWeight[])(object)new BoneWeight[n + count];
			Array.Copy(rend.weights, weights, n);
			for (int i = 0; i < count; i++)
			{
				weights[n + i] = split.bw[i];
			}
			cap.newWeights = weights;
			FlattenSkinWeights((int num2) => weights[num2], weights.Length, out cap.bwPerVert, out cap.bwFlat, out cap.bwFlatCount);
			if (rend.canon != null)
			{
				int[] array4 = new int[n + count];
				Array.Copy(rend.canon, array4, Math.Min(rend.canon.Length, n));
				for (int num = rend.canon.Length; num < n + count; num++)
				{
					array4[num] = num;
				}
				cap.newCanon = array4;
			}
			cap.coreT = coreT;
		}

		private static T[] Concat<T>(T[] a, List<T> b)
		{
			T[] array = new T[a.Length + b.Count];
			Array.Copy(a, array, a.Length);
			for (int i = 0; i < b.Count; i++)
			{
				array[a.Length + i] = b[i];
			}
			return array;
		}

		private static void FlattenSkinWeights(Func<int, BoneWeight> w, int count, out byte[] perVert, out BoneWeight1[] flat, out int flatCount)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			perVert = new byte[count];
			flat = (BoneWeight1[])(object)new BoneWeight1[count * 4];
			int num = 0;
			int[] array = new int[4];
			float[] array2 = new float[4];
			for (int i = 0; i < count; i++)
			{
				BoneWeight val = w(i);
				int num2 = 0;
				if (((BoneWeight)(ref val)).weight0 > 0f)
				{
					array[num2] = ((BoneWeight)(ref val)).boneIndex0;
					array2[num2++] = ((BoneWeight)(ref val)).weight0;
				}
				if (((BoneWeight)(ref val)).weight1 > 0f)
				{
					array[num2] = ((BoneWeight)(ref val)).boneIndex1;
					array2[num2++] = ((BoneWeight)(ref val)).weight1;
				}
				if (((BoneWeight)(ref val)).weight2 > 0f)
				{
					array[num2] = ((BoneWeight)(ref val)).boneIndex2;
					array2[num2++] = ((BoneWeight)(ref val)).weight2;
				}
				if (((BoneWeight)(ref val)).weight3 > 0f)
				{
					array[num2] = ((BoneWeight)(ref val)).boneIndex3;
					array2[num2++] = ((BoneWeight)(ref val)).weight3;
				}
				for (int j = 1; j < num2; j++)
				{
					int num3 = j;
					while (num3 > 0 && array2[num3] > array2[num3 - 1])
					{
						ref float reference = ref array2[num3];
						ref float reference2 = ref array2[num3 - 1];
						float num4 = array2[num3 - 1];
						float num5 = array2[num3];
						reference = num4;
						reference2 = num5;
						ref int reference3 = ref array[num3];
						ref int reference4 = ref array[num3 - 1];
						int num6 = array[num3 - 1];
						int num7 = array[num3];
						reference3 = num6;
						reference4 = num7;
						num3--;
					}
				}
				BoneWeight1 val2;
				if (num2 == 0)
				{
					BoneWeight1[] obj = flat;
					int num8 = num++;
					val2 = default(BoneWeight1);
					((BoneWeight1)(ref val2)).boneIndex = ((BoneWeight)(ref val)).boneIndex0;
					((BoneWeight1)(ref val2)).weight = 1f;
					obj[num8] = val2;
					perVert[i] = 1;
					continue;
				}
				for (int k = 0; k < num2; k++)
				{
					BoneWeight1[] obj2 = flat;
					int num9 = num++;
					val2 = default(BoneWeight1);
					((BoneWeight1)(ref val2)).boneIndex = array[k];
					((BoneWeight1)(ref val2)).weight = array2[k];
					obj2[num9] = val2;
				}
				perVert[i] = (byte)num2;
			}
			flatCount = num;
		}

		private static void ApplySkinWeightsFlat(Mesh m, byte[] perVert, BoneWeight1[] flat, int flatCount)
		{
			//IL_0014: 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)
			NativeArray<byte> val = default(NativeArray<byte>);
			val..ctor(perVert, (Allocator)2);
			NativeArray<BoneWeight1> val2 = default(NativeArray<BoneWeight1>);
			val2..ctor(flatCount, (Allocator)2, (NativeArrayOptions)0);
			NativeArray<BoneWeight1>.Copy(flat, val2, flatCount);
			m.SetBoneWeights(val, val2);
			val.Dispose();
			val2.Dispose();
		}

		internal static void ClearCutLog()
		{
			cutLog.Clear();
		}

		private static void RecordCut(Corpse c, Rend rend, CutReq req, Vector3[] wv, List<int>[] coreT, List<int>[] farT, SplitVerts split, bool dropped)
		{
			//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_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)
			int[][] array = new int[rend.ext.Length][];
			for (int i = 0; i < rend.ext.Length; i++)
			{
				array[i] = rend.ext[i].ToArray();
			}
			int num = 0;
			int num2 = 0;
			List<int>[] array2 = coreT;
			foreach (List<int> list in array2)
			{
				num += list.Count / 3;
			}
			array2 = farT;
			foreach (List<int> list2 in array2)
			{
				num2 += list2.Count / 3;
			}
			if (cutLog.Count >= 12)
			{
				cutLog.RemoveAt(0);
			}
			cutLog.Add(new CutRecord
			{
				corpse = (((Object)(object)c.modelTf != (Object)null) ? ((Object)c.modelTf).name : "?"),
				rend = (((Object)(object)rend.smr != (Object)null) ? ((Object)rend.smr).name : "?"),
				shape = req.shape,
				style = req.style,
				pos = req.pos,
				dir = req.dir,
				radius = req.radius,
				boost = req.boost,
				time = Time.time,
				coreVert = rend.coreVert,
				splitCount = split.Count,
				dropped = dropped,
				wv = (Vector3[])wv.Clone(),
				canon = ((rend.canon != null) ? ((int[])rend.canon.Clone()) : null),
				ext = array,
				splitPos = split.worldPos.ToArray(),
				coreTris = num,
				farTris = num2
			});
		}

		internal static void WriteDebugState(BinaryWriter w)
		{
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			w.Write(corpses.Count);
			foreach (Corpse corpse in corpses)
			{
				w.Write(((Object)(object)corpse.modelTf != (Object)null) ? ((Object)corpse.modelTf).name : "");
				w.Write(corpse.palette);
				w.Write(corpse.radius);
				w.Write(corpse.cuts);
				w.Write(((Object)(object)corpse.coreBone != (Object)null) ? ((Object)corpse.coreBone).name : "");
				w.Write(corpse.rends.Count);
				foreach (Rend rend in corpse.rends)
				{
					w.Write(((Object)(object)rend.smr != (Object)null) ? ((Object)rend.smr).name : "");
					w.Write(rend.dead);
					w.Write(((Object)(object)rend.smr != (Object)null && (Object)(object)rend.smr.sharedMesh != (Object)null) ? rend.smr.sharedMesh.vertexCount : 0);
					w.Write((rend.ext != null) ? rend.ext.Length : 0);
					w.Write(((Object)(object)rend.smr != (Object)null) ? ((Renderer)rend.smr).sharedMaterials.Length : 0);
					w.Write((Object)(object)rend.innardsGo != (Object)null);
				}
			}
			w.Write(pieces.Count);
			foreach (Piece piece in pieces)
			{
				w.Write(((Object)(object)piece.go != (Object)null) ? ((Object)piece.go).name : "");
				w.Write(piece.palette);
				w.Write(piece.cuts);
				w.Write(((Object)(object)piece.mesh != (Object)null) ? piece.mesh.vertexCount : 0);
				Vector3 val = (((Object)(object)piece.tf != (Object)null) ? piece.tf.position : Vector3.zero);
				w.Write(val.x);
				w.Write(val.y);
				w.Write(val.z);
			}
		}

		internal static void WriteCutLog(BinaryWriter w)
		{
			//IL_0115: 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_011d: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			w.Write(cutLog.Count);
			foreach (CutRecord item in cutLog)
			{
				w.Write(item.corpse);
				w.Write(item.rend);
				w.Write(item.shape);
				w.Write(item.style);
				w.Write(item.pos.x);
				w.Write(item.pos.y);
				w.Write(item.pos.z);
				w.Write(item.dir.x);
				w.Write(item.dir.y);
				w.Write(item.dir.z);
				w.Write(item.radius);
				w.Write(item.boost);
				w.Write(item.time);
				w.Write(item.coreVert);
				w.Write(item.dropped);
				w.Write(item.wv.Length);
				Vector3[] wv = item.wv;
				foreach (Vector3 val in wv)
				{
					w.Write(val.x);
					w.Write(val.y);
					w.Write(val.z);
				}
				w.Write((item.canon != null) ? item.canon.Length : 0);
				if (item.canon != null)
				{
					int[] canon = item.canon;
					foreach (int value in canon)
					{
						w.Write(value);
					}
				}
				w.Write(item.ext.Length);
				int[][] ext = item.ext;
				foreach (int[] array in ext)
				{
					w.Write(array.Length);
					int[] canon = array;
					foreach (int value2 in canon)
					{
						w.Write(value2);
					}
				}
				w.Write(item.splitCount);
				w.Write(item.splitPos.Length);
				wv = item.splitPos;
				foreach (Vector3 val2 in wv)
				{
					w.Write(val2.x);
					w.Write(val2.y);
					w.Write(val2.z);
				}
				w.Write(item.coreTris);
				w.Write(item.farTris);
			}
		}

		private static bool TakeEatBite(Corpse c)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			if (tickHasEye)
			{
				Vector3 val = (((Object)(object)c.refBone != (Object)null) ? c.refBone.position : c.center) - tickEye;
				if (((Vector3)(ref val)).sqrMagnitude > 4900f)
				{
					return false;
				}
			}
			float time = Time.time;
			if (time - eatWindowStart >= 1f)
			{
				eatWindowStart = time;
				eatWindowCount = 0;
			}
			if (eatWindowCount >= 12)
			{
				return false;
			}
			eatWindowCount++;
			return true;
		}

		private static void ElementStart(Corpse c, GoreSystem.Blow blow)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: 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_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: 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_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: 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_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: 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)
			c.element = blow.element;
			c.oiled = blow.oiled;
			if (c.element == 0)
			{
				return;
			}
			long t = GoreProf.Begin();
			float time = Time.time;
			Vector3 center = c.center;
			c.ovk = (float)blow.overkill / 64f;
			float num = Mathf.Clamp01((c.ovk - 1.5f) / 3.5f);
			Vector3 val2;
			switch (c.element)
			{
			case 3:
			case 4:
			case 9:
				c.elemSpan = Mathf.Lerp(7f, 3f, num);
				c.nextElem = time + 0.3f;
				break;
			case 1:
			case 2:
				c.elemSpan = Mathf.Lerp(4.2f, 1.3f, num);
				c.nextElem = time + 0.15f;
				if (num > 0f)
				{
					GoreSystem.ElementMotes(c.element, center, Mathf.RoundToInt(12f + 24f * num));
				}
				break;
			case 5:
			{
				c.elemSpan = 2.6f;
				c.nextElem = time + 0.35f;
				c.elemPhase = 1f;
				int num3 = ((blow.kind == 3 || blow.kind == 0) ? 2 : 0) + ((c.ovk >= 2f) ? 2 : 0);
				val2 = RandomInSphere();
				Vector3 val3 = ((Vector3)(ref val2)).normalized;
				if (((Vector3)(ref val3)).sqrMagnitude < 0.01f)
				{
					val3 = Vector3.up;
				}
				for (int j = 0; j < num3; j++)
				{
					Vector3 val4;
					switch (j)
					{
					default:
						val2 = RandomInSphere();
						val4 = ((Vector3)(ref val2)).normalized;
						break;
					case 1:
						val2 = Vector3.Cross(val3, RandomInSphere());
						val4 = ((Vector3)(ref val2)).normalized;
						break;
					case 0:
						val4 = val3;
						break;
					}
					Vector3 dir2 = val4;
					if (((Vector3)(ref dir2)).sqrMagnitude < 0.01f)
					{
						dir2 = ((j % 2 == 0) ? Vector3.up : Vector3.right);
					}
					CutReq req2 = new CutReq
					{
						c = c,
						shape = 0,
						style = 6,
						pos = center + ((j == 0) ? Vector3.zero : (RandomInSphere() * (c.radius * 0.18f))),
						dir = dir2
					};
					if (j == 0 && TakeInstantKillCut())
					{
						RunCutNow(c, req2);
					}
					else
					{
						Enqueue(req2);
					}
				}
				if (c.ovk >= 2f)
				{
					GoreSystem.ElementMotes(5, center, Mathf.RoundToInt(14f + 20f * num));
				}
				break;
			}
			case 6:
				c.elemSpan = 1.5f * (1f + num);
				c.nextElem = time + 0.05f;
				break;
			case 7:
			{
				c.elemSpan = 1.3f;
				c.nextElem = time + 0.1f;
				if (blow.kind != 0 && blow.kind != 3)
				{
					break;
				}
				float boost = 1f + num * 0.8f;
				Vector3 val = center + RandomInSphere() * (c.radius * 0.2f);
				CutReq req = new CutReq
				{
					c = c,
					shape = 1,
					style = 7,
					pos = val,
					radius = c.radius * 0.8f * 0.45f,
					boost = boost
				};
				if (TakeInstantKillCut())
				{
					RunCutNow(c, req);
				}
				else
				{
					Enqueue(req);
				}
				int num2 = ((!(c.ovk >= 2f)) ? 1 : 2);
				for (int i = 0; i < num2; i++)
				{
					val2 = RandomInSphere();
					Vector3 dir = ((Vector3)(ref val2)).normalized;
					if (((Vector3)(ref dir)).sqrMagnitude < 0.01f)
					{
						dir = ((i == 0) ? Vector3.up : Vector3.right);
					}
					Enqueue(new CutReq
					{
						c = c,
						shape = 0,
						style = 7,
						pos = val + RandomInSphere() * (c.radius * 0.2f),
						dir = dir,
						boost = boost
					});
				}
				break;
			}
			case 8:
				c.elemSpan = 3f * (1f + 0.7f * num);
				c.nextElem = time + 0.2f;
				break;
			}
			c.elemUntil = time + c.elemSpan;
			if (c.element == 5)
			{
				ApplyCorpseTint(c);
			}
			GoreProf.End(10, t);
		}

		private static void ElementTick(Corpse c, float now)
		{
			if (!GoreProf.On || c.element == 0)
			{
				ElementTickInner(c, now);
				return;
			}
			long t = GoreProf.Begin();
			ElementTickInner(c, now);
			GoreProf.End(GoreProf.ElemSlot(c.element), t);
		}

		private static void ElementTickInner(Corpse c, float now)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: 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_02e7: 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_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: 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_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: 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_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: 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_011c: 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_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: 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_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: 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_01c3: Unknown result type (might be due to invalid IL or missing references)
			if (now < c.smokeUntil && now >= c.nextSmoke)
			{
				c.nextSmoke = now + 0.3f;
				GoreSystem.SmokePuffs(RandomBoneSpot(c), 1);
			}
			if (c.element == 0 || now < c.nextElem)
			{
				return;
			}
			if (now > c.elemUntil)
			{
				c.nextElem = float.MaxValue;
				if (c.element == 1 || c.element == 2)
				{
					c.smokeUntil = now + 2.8f;
					c.nextSmoke = now;
				}
				return;
			}
			float num = Mathf.Clamp01(1f - (c.elemUntil - now) / Mathf.Max(c.elemSpan, 0.1f));
			switch (c.element)
			{
			case 3:
			case 4:
			case 9:
				c.nextElem = now + 0.15f;
				c.elemStep++;
				c.elemPhase = num;
				ApplyCorpseTint(c);
				if (c.elemStep % ((c.ovk >= 1.5f) ? 2 : 3) == 0)
				{
					Vector3 val = RandomBoneSpot(c);
					if (Cuttable(c) && TakeEatBite(c))
					{
						Enqueue(new CutReq
						{
							c = c,
							shape = 1,
							style = 5,
							pos = val,
							radius = Mathf.Clamp(c.radius * 0.19f, 0.2f, 0.6f)
						});
					}
					GoreSystem.ElementSizzle(c.element, val);
					GoreSystem.Dribble(val, PieceDripPalette(c.element, c.palette));
					if (c.elemStep % 6 == 0)
					{
						GoreSystem.ElementPool(c.element, ((Object)(object)c.refBone != (Object)null) ? c.refBone.position : val, c.radius * 1.1f);
					}
				}
				break;
			case 1:
			case 2:
				c.nextElem = now + 0.28f;
				c.elemStep++;
				c.elemPhase = Mathf.Pow(num, 0.7f);
				ApplyCorpseTint(c);
				GoreSystem.ElementMotes(c.element, RandomBoneSpot(c), c.oiled ? 5 : 4);
				if (c.elemStep == 5 || c.elemStep == 11)
				{
					GoreSystem.ElementPool(c.element, ((Object)(object)c.refBone != (Object)null) ? c.refBone.position : c.modelTf.position, c.radius * 0.8f);
				}
				break;
			case 5:
				c.nextElem = now + 0.4f;
				ApplyCorpseTint(c);
				GoreSystem.ElementMotes(5, RandomBoneSpot(c), 4);
				break;
			case 6:
			{
				c.nextElem = now + 0.11f;
				c.elemStep++;
				c.elemPhase = num;
				ApplyCorpseTint(c);
				bool flag = c.ovk >= 1.5f;
				Vector3 val2 = RandomBoneSpot(c);
				Vector3 val3 = RandomBoneSpot(c);
				Vector3 val4 = val2 - val3;
				if (((Vector3)(ref val4)).sqrMagnitude > 0.04f)
				{
					GoreSystem.ArcFlash(val2, val3);
				}
				if (flag)
				{
					Vector3 val5 = RandomBoneSpot(c);
					Vector3 val6 = RandomBoneSpot(c);
					val4 = val5 - val6;
					if (((Vector3)(ref val4)).sqrMagnitude > 0.04f)
					{
						GoreSystem.ArcFlash(val5, val6);
					}
				}
				if (TryNearestPieceSpot(val2, 7f, out var spot))
				{
					GoreSystem.ArcFlash(val2, spot);
				}
				if ((flag || c.elemStep % 2 == 0) && TryNearestCorpseSpot(c, 10f, out var spot2))
				{
					GoreSystem.ArcFlash(val2, spot2);
					GoreSystem.ElementMotes(6, spot2, 2);
				}
				GoreSystem.ElementMotes(6, val3, flag ? 4 : 3);
				if (c.elemStep == 2 || c.elemStep == 5 || c.elemStep == 9 || (flag && c.elemStep == 13))
				{
					Jolt(c);
				}
				break;
			}
			case 7:
				c.nextElem = now + 0.12f;
				c.elemPhase = num;
				ApplyCorpseTint(c);
				GoreSystem.VoidImplosion(RandomBoneSpot(c), c.radius * 1.2f, (c.ovk >= 1.5f) ? 4 : 2);
				GoreSystem.ElementMotes(7, RandomBoneSpot(c), 2);
				break;
			case 8:
				c.nextElem = now + 0.22f;
				c.elemPhase = num;
				ApplyCorpseTint(c);
				GoreSystem.ElementMotes(8, RandomBoneSpot(c), (c.ovk >= 1.5f) ? 4 : 2);
				break;
			}
		}

		private static void PieceElementTick(Piece p, float now)
		{
			if (!GoreProf.On || p.element == 0)
			{
				PieceElementTickInner(p, now);
				return;
			}
			long t = GoreProf.Begin();
			PieceElementTickInner(p, now);
			GoreProf.End(17, t);
		}

		private static void PieceElementTickInner(Piece p, float now)
		{
			//IL_010f: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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)
			if (p.element == 0 || (Object)(object)p.mr == (Object)null)
			{
				return;
			}
			switch (p.element)
			{
			case 1:
			case 2:
				if (!(now < p.nextFx))
				{
					p.nextFx = now + 0.26f;
					float num2 = Mathf.Clamp01(p.phase0 + (now - p.born) / 4.2f);
					ApplyCharTint((Renderer)(object)p.mr, num2, p.element == 2, now, p.born);
					if (num2 < 1f)
					{
						GoreSystem.ElementMotes(p.element, p.tf.position, 1);
					}
				}
				break;
			case 3:
			case 4:
			case 9:
			{
				float num = Mathf.Clamp01(p.phase0 + (now - p.born) / Mathf.Max(p.dieAt - p.born, 0.1f) * (1f - p.phase0));
				p.dissolve = 1f - 0.6f * num;
				p.tf.localScale = Vector3.one * p.dissolve;
				if (!(now < p.nextFx))
				{
					p.nextFx = now + 0.28f;
					ApplyAcidTint((Renderer)(object)p.mr, p.element, num, now, p.born);
					GoreSystem.ElementMotes(p.element, p.tf.position, 2);
				}
				break;
			}
			case 5:
				if (!(now < p.nextFx))
				{
					p.nextFx = now + 0.6f;
					GoreSystem.ElementMotes(5, p.tf.position, 1);
				}
				break;
			case 7:
				if (!(now < p.nextFx))
				{
					p.nextFx = now + 0.4f;
					GoreSystem.ElementMotes(7, p.tf.position, 1);
				}
				break;
			case 6:
			case 8:
				break;
			}
		}

		private static void DressPiece(Piece p, Corpse c, CutReq req)
		{
			p.element = c.element;
			p.phase0 = c.elemPhase;
			switch (req.style)
			{
			case 5:
				p.dieAt = p.born + 2.4f + (float)rng.NextDouble() * 1.4f;
				p.dribbleUntil = p.born + 1.2f;
				break;
			case 6:
				p.dribbleUntil = p.born;
				break;
			}
			p.dripPalette = PieceDripPalette(c.element, c.palette);
			switch (c.element)
			{
			case 5:
				p.dribbleUntil = Mathf.Min(p.dribbleUntil, p.born + 0.4f);
				ApplyFrostTint((Renderer)(object)p.mr, 1f);
				break;
			case 1:
			case 2:
				if (p.phase0 > 0.01f)
				{
					ApplyCharTint((Renderer)(object)p.mr, p.phase0, c.element == 2, Time.time, p.born);
				}
				break;
			case 3:
			case 4:
			case 9:
				if (p.phase0 > 0.01f)
				{
					ApplyAcidTint((Renderer)(object)p.mr, c.element, p.phase0, Time.time, p.born);
				}
				break;
			case 6:
			case 7:
			case 8:
				break;
			}
		}

		private static void InheritPieceElement(Piece sub, Piece parent)
		{
			sub.element = parent.element;
			switch (parent.element)
			{
			case 1:
			case 2:
				sub.phase0 = Mathf.Clamp01(parent.phase0 + (sub.born - parent.born) / 4.2f);
				if (sub.phase0 > 0.01f)
				{
					ApplyCharTint((Renderer)(object)sub.mr, sub.phase0, parent.element == 2, sub.born, sub.born);
				}
				break;
			case 5:
				ApplyFrostTint((Renderer)(object)sub.mr, 1f);
				break;
			case 3:
			case 4:
			case 9:
				sub.dieAt = sub.born + 2.2f;
				sub.phase0 = Mathf.Clamp01(parent.phase0 + (sub.born - parent.born) / Mathf.Max(parent.dieAt - parent.born, 0.1f));
				sub.dissolve = 1f - 0.6f * sub.phase0;
				break;
			case 6:
			case 7:
			case 8:
				break;
			}
		}

		private static void ApplyCorpseTint(Corpse c)
		{
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c.modelTf == (Object)null)
			{
				return;
			}
			long t = GoreProf.Begin();
			float time = Time.time;
			float num = c.radius * 7.3f;
			if (c.tintRendsAtCuts != c.cuts)
			{
				c.tintRendsAtCuts = c.cuts;
				c.tintRends.Clear();
				((Component)c.modelTf).GetComponentsInChildren<Renderer>(false, tintScratch);
				foreach (Renderer item in tintScratch)
				{
					if ((Object)(object)item != (Object)null && (item is SkinnedMeshRenderer || item is MeshRenderer))
					{
						c.tintRends.Add(item);
					}
				}
				tintScratch.Clear();
			}
			foreach (Renderer tintRend in c.tintRends)
			{
				if (!((Object)(object)tintRend == (Object)null))
				{
					switch (c.element)
					{
					case 1:
						ApplyCharTint(tintRend, c.elemPhase, helfire: false, time, num);
						break;
					case 2:
						ApplyCharTint(tintRend, c.elemPhase, helfire: true, time, num);
						break;
					case 3:
					case 4:
					case 9:
						ApplyAcidTint(tintRend, c.element, c.elemPhase, time, num);
						break;
					case 5:
						ApplyFrostTint(tintRend, c.elemPhase);
						break;
					case 6:
					{
						float num2 = (1f - c.elemPhase) * (0.55f + 0.45f * Mathf.Sin(time * 6f + num));
						ApplyGlow(tintRend, ArcGlow * num2);
						break;
					}
					case 7:
						ApplyGlow(tintRend, VoidGlow * (1f - c.elemPhase));
						break;
					case 8:
						ApplyGlow(tintRend, LunarGlow * Mathf.Sin(c.elemPhase * MathF.PI));
						break;
					}
				}
			}
			GoreProf.End(18, t);
		}

		private static void ApplyCharTint(Renderer r, float phase, bool helfire, float now, float seed)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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)
			Color col = Color.Lerp(Color.white, CharSkin, phase);
			float num = 0.78f + 0.22f * Mathf.Sin(now * 3.4f + seed * 5.3f);
			Color em = (helfire ? HelfireGlow : EmberGlow) * (num * (1f - phase * 0.8f));
			ApplyBlock(r, col, em, -1f);
		}

		private static void ApplyAcidTint(Renderer r, byte elem, float phase, float now, float seed)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_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)
			//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_0085: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			Color val = (Color)(elem switch
			{
				9 => NanoSkin, 
				4 => BlightSkin, 
				_ => AcidSkin, 
			});
			? val2 = elem switch
			{
				9 => NanoPulse, 
				4 => BlightPulse, 
				_ => AcidPulse, 
			};
			Color col = Color.Lerp(Color.white, val, Mathf.Clamp01(phase * 1.3f));
			float num = 0.75f + 0.25f * Mathf.Sin(now * 2.6f + seed);
			Color em = (Color)val2 * (num * Mathf.Clamp(phase * 2.5f, 0.25f, 1f));
			col.a = ((phase > 0.45f) ? Mathf.Lerp(1f, 0.3f, (phase - 0.45f) / 0.55f) : 1f);
			ApplyBlock(r, col, em, -1f);
		}

		private static void ApplyFrostTint(Renderer r, float phase)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			ApplyBlock(r, Color.Lerp(Color.white, FrostSkin, phase), FrostGlow * phase, 0.85f);
		}

		private static void ApplyBlock(Renderer r, Color col, Color em, float smooth)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			if (!((Object)(object)r == (Object)null))
			{
				if (tintBlock == null)
				{
					tintBlock = new MaterialPropertyBlock();
				}
				r.GetPropertyBlock(tintBlock);
				tintBlock.SetColor(PropColor, col);
				tintBlock.SetColor(PropEmColor, em);
				tintBlock.SetColor(PropEmission, em);
				if (((Color)(ref em)).maxColorComponent > 0f)
				{
					tintBlock.SetFloat(PropEmPower, 1f);
				}
				if (smooth >= 0f)
				{
					tintBlock.SetFloat(PropSmoothness, smooth);
				}
				r.SetPropertyBlock(tintBlock);
			}
		}

		private static void ApplyGlow(Renderer r, Color em)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			if (!((Object)(object)r == (Object)null))
			{
				if (tintBlock == null)
				{
					tintBlock = new MaterialPropertyBlock();
				}
				r.GetPropertyBlock(tintBlock);
				tintBlock.SetColor(PropEmColor, em);
				tintBlock.SetColor(PropEmission, em);
				if (((Color)(ref em)).maxColorComponent > 0f)
				{
					tintBlock.SetFloat(PropEmPower, 1f);
				}
				r.SetPropertyBlock(tintBlock);
			}
		}

		private static int PieceDripPalette(byte elem, int fallback)
		{
			int num = fallback & 0x10;
			return elem switch
			{
				3 => 7 | num, 
				4 => 8 | num, 
				9 => 1 | num, 
				5 => 9 | num, 
				_ => fallback, 
			};
		}

		internal static void OnBlastWave(Vector3 pos, float r)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			float num = r + 2.5f;
			foreach (Piece piece in pieces)
			{
				if ((Object)(object)piece.go == (Object)null)
				{
					continue;
				}
				Vector3 val = piece.tf.position - pos;
				float magnitude = ((Vector3)(ref val)).magnitude;
				if (!(magnitude > num))
				{
					Rigidbody rb = piece.rb;
					if ((Object)(object)rb != (Object)null && !rb.isKinematic)
					{
						Vector3 val2 = ((magnitude > 0.01f) ? (val / magnitude) : Vector3.up);
						float num2 = Mathf.Lerp(9f, 2.5f, magnitude / num);
						rb.AddForce(val2 * num2 + Vector3.up * (num2 * 0.45f), (ForceMode)2);
						rb.AddTorque(RandomInSphere() * num2, (ForceMode)2);
					}
					if (piece.element == 0)
					{
						piece.element = 1;
						piece.phase0 = 0.2f;
						piece.born = time;
						piece.nextFx = time;
					}
					else if (piece.element == 1 || piece.element == 2)
					{
						piece.phase0 = Mathf.Min(piece.phase0 + 0.15f, 0.9f);
					}
					GoreSystem.ElementMotes(1, piece.tf.position, 2);
				}
			}
		}

		private static bool TryNearestCorpseSpot(Corpse self, float maxDist, out Vector3 spot)
		{
			//IL_0001: 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_0021: 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_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)
			//IL_007d: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			spot = default(Vector3);
			float num = maxDist * maxDist;
			bool result = false;
			Vector3 val = (((Object)(object)self.refBone != (Object)null) ? self.refBone.position : self.modelTf.position);
			foreach (Corpse corpse in corpses)
			{
				if (corpse != self && !((Object)(object)corpse.modelTf == (Object)null) && !((Object)(object)corpse.refBone == (Object)null))
				{
					Vector3 val2 = corpse.refBone.position - val;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num && sqrMagnitude > 1f)
					{
						num = sqrMagnitude;
						spot = corpse.refBone.position + RandomInSphere() * (corpse.radius * 0.3f);
						result = true;
					}
				}
			}
			return result;
		}

		private static bool TryNearestPieceSpot(Vector3 from, float maxDist, out Vector3 spot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			spot = default(Vector3);
			float num = maxDist * maxDist;
			bool result = false;
			foreach (Piece piece in pieces)
			{
				if (!((Object)(object)piece.go == (Object)null))
				{
					Vector3 val = piece.tf.position - from;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude < num && sqrMagnitude > 0.25f)
					{
						num = sqrMagnitude;
						spot = piece.tf.position;
						result = true;
					}
				}
			}
			return result;
		}

		private static Vector3 RandomBoneSpot(Corpse c)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			int count = c.allBones.Count;
			for (int i = 0; i < 6; i++)
			{
				if (count <= 0)
				{
					break;
				}
				Transform val = c.allBones[rng.Next(count)];
				if ((Object)(object)val != (Object)null)
				{
					return val.position + RandomInSphere() * (c.radius * 0.25f);
				}
			}
			if (!((Object)(object)c.refBone != (Object)null))
			{
				return c.modelTf.position;
			}
			return c.refBone.position;
		}

		private static void Jolt(Corpse c)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			long t = GoreProf.Begin();
			int num = 0;
			int count = c.allBones.Count;
			for (int i = 0; i < count; i++)
			{
				if (num >= 4)
				{
					break;
				}
				Transform val = c.allBones[(i * 7 + c.elemStep) % count];
				if (!((Object)(object)val == (Object)null))
				{
					Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
					if (!((Object)(object)component == (Object)null) && !component.isKinematic)
					{
						component.AddForce((RandomInSphere() + Vector3.up * 0.6f) * (component.mass * 2.2f), (ForceMode)1);
						num++;
					}
				}
			}
			GoreProf.End(26, t);
		}

		private static void MarkInnards(Corpse c, Rend rend, List<Vector3> boneSpots)
		{
			if (boneSpots != null && boneSpots.Count > 0)
			{
				(rend.innardsSpots ?? (rend.innardsSpots = new List<Vector3>())).AddRange(boneSpots);
			}
			if (!rend.innardsDirty)
			{
				rend.innardsDirty = true;
				innardsQueue.Add(new InnardsReq
				{
					c = c,
					rend = rend
				});
			}
		}

		private static void DrainInnardsQueue()
		{
			if (innardsQueue.Count == 0)
			{
				return;
			}
			int num = 0;
			float time = Time.time;
			int count = innardsQueue.Count;
			while (count-- > 0 && innardsQueue.Count > 0 && num < 2)
			{
				InnardsReq item = innardsQueue[0];
				innardsQueue.RemoveAt(0);
				if (time < item.rend.nextInnardsAt || item.c.cutBusy || item.rend.innardsBusy)
				{
					innardsQueue.Add(item);
					continue;
				}
				item.rend.innardsDirty = false;
				List<Vector3> innardsSpots = item.rend.innardsSpots;
				item.rend.innardsSpots = null;
				if (!((Object)(object)item.c.modelTf == (Object)null) && !item.rend.dead && !((Object)(object)item.rend.smr == (Object)null) && byModel.TryGetValue(item.c.modelTf, out var value) && value == item.c)
				{
					InnardsJob innardsJob = CaptureInnards(item.c, item.rend, innardsSpots);
					if (innardsJob != null)
					{
						item.rend.nextInnardsAt = time + 0.4f;
						item.rend.innardsBusy = true;
						num++;
						SubmitJob(innardsJob);
					}
				}
			}
		}

		private static InnardsJob CaptureInnards(Corpse c, Rend rend, List<Vector3> boneSpots)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_0089: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			if (rend.ext == null || rend.bindPos == null || rend.weights == null)
			{
				return null;
			}
			if ((Object)(object)GoreSystem.FleshMaterial(c.palette) == (Object)null)
			{
				return null;
			}
			if (rend.bindPerWorld <= 0f)
			{
				rend.bindPerWorld = 1f;
				Mesh sharedMesh = rend.smr.sharedMesh;
				if ((Object)(object)sharedMesh != (Object)null)
				{
					Bounds bounds = ((Renderer)rend.smr).bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					float magnitude = ((Vector3)(ref size)).magnitude;
					bounds = sharedMesh.bounds;
					size = ((Bounds)(ref bounds)).size;
					float magnitude2 = ((Vector3)(ref size)).magnitude;
					if (magnitude > 0.01f && magnitude2 > 0.001f)
					{
						rend.bindPerWorld = magnitude2 / magnitude;
					}
				}
			}
			InnardsJob innardsJob = new InnardsJob
			{
				c = c,
				rend = rend,
				boneSpots = boneSpots,
				ext = rend.ext,
				bindPos = rend.bindPos,
				bindNrm = rend.bindNrm,
				weights = rend.weights,
				canon = rend.canon,
				bindPerWorld = rend.bindPerWorld,
				wantBone = ((Object)(object)GoreSystem.BoneMaterial(c.palette) != (Object)null)
			};
			if (innardsJob.wantBone && boneSpots != null && boneSpots.Count > 0)
			{
				innardsJob.skin = (Matrix4x4[])BuildSkinMatrices(rend).Clone();
				innardsJob.skinFallback = ((Component)rend.smr).transform.localToWorldMatrix;
			}
			return innardsJob;
		}

		private static void ComputeInnards(InnardsJob job)
		{
			//IL_090b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0923: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: 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_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: 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_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: 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_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a38: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Unknown result type (might be due to invalid IL or missing references)
			//IL_050d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a79: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a94: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0568: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0adb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b28: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0600: Unknown result type (might be due to invalid IL or missing references)
			//IL_0607: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_0646: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_067c: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0705: Unknown result type (might be due to invalid IL or missing references)
			//IL_071c: Unknown result type (might be due to invalid IL or missing references)
			//IL_072f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0734: Unknown result type (might be due to invalid IL or missing references)
			//IL_0736: Unknown result type (might be due to invalid IL or missing references)
			//IL_0743: Unknown result type (might be due to invalid IL or missing references)
			//IL_0748: Unknown result type (might be due to invalid IL or missing references)
			//IL_074a: Unknown result type (might be due to invalid IL or missing references)
			//IL_074f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0754: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0813: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Unknown result type (might be due to invalid IL or missing references)
			//IL_0819: Unknown result type (might be due to invalid IL or missing references)
			//IL_081e: Unknown result type (might be due to invalid IL or missing references)
			//IL_080e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0845: Unknown result type (might be due to invalid IL or missing references)
			//IL_084a: Unknown result type (might be due to invalid IL or missing references)
			//IL_084c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0851: Unknown result type (might be due to invalid IL or missing references)
			//IL_089a: Unknown result type (might be due to invalid IL or missing references)
			//IL_089c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bb: Unknown result type (might be due to invalid IL or missing references)
			long timestamp = Stopwatch.GetTimestamp();
			List<int>[] ext = job.ext;
			List<int> list = (job.wantBone ? new List<int>() : null);
			int num = job.bindPos.Length;
			List<int>[] array = ext;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].Count >= 3)
				{
					job.anyCore = true;
					break;
				}
			}
			if (!job.anyCore)
			{
				return;
			}
			long timestamp2 = Stopwatch.GetTimestamp();
			List<int> list2 = BoundaryEdges(ext, job.canon);
			job.phEdges += Stopwatch.GetTimestamp() - timestamp2;
			if (list2.Count < 4)
			{
				list2.Clear();
			}
			float bindPerWorld = job.bindPerWorld;
			Vector3[] bindPos = job.bindPos;
			Vector3[] bindNrm = job.bindNrm;
			BoneWeight[] weights = job.weights;
			bool flag = bindNrm != null;
			int num2 = 0;
			array = ext;
			foreach (List<int> list3 in array)
			{
				num2 += list3.Count / 3;
			}
			bool flag2 = num2 <= 8000;
			job.extTris = num2;
			List<Vector3> pos = new List<Vector3>((flag2 && flag) ? (num * 2 + 8) : (num / 4 + 8));
			List<Vector3> nrm = (flag ? new List<Vector3>(pos.Capacity) : null);
			List<BoneWeight> wts = new List<BoneWeight>(pos.Capacity);
			List<int> list4 = new List<int>();
			float num3 = 0f;
			Dictionary<int, int> ringDup;
			Vector3 val4;
			if (flag)
			{
				float num4 = 0.008f * bindPerWorld;
				if (flag2)
				{
					timestamp2 = Stopwatch.GetTimestamp();
					Vector3[] array2 = (Vector3[])(object)new Vector3[num];
					array = ext;
					foreach (List<int> list5 in array)
					{
						for (int j = 0; j + 2 < list5.Count; j += 3)
						{
							Vector3 val = Vector3.Cross(bindPos[list5[j + 1]] - bindPos[list5[j]], bindPos[list5[j + 2]] - bindPos[list5[j]]);
							ref Vector3 reference = ref array2[list5[j]];
							reference += val;
							ref Vector3 reference2 = ref array2[list5[j + 1]];
							reference2 += val;
							ref Vector3 reference3 = ref array2[list5[j + 2]];
							reference3 += val;
						}
					}
					for (int k = 0; k < num; k++)
					{
						Vector3 val2 = ((Vector3.Dot(bindNrm[k], array2[k]) < 0f) ? (-bindNrm[k]) : bindNrm[k]);
						pos.Add(bindPos[k] - val2 * num4);
						nrm.Add(val2);
						wts.Add(weights[k]);
					}
					for (int l = 0; l < num; l++)
					{
						pos.Add(pos[l]);
						nrm.Add(-nrm[l]);
						wts.Add(weights[l]);
					}
					array = ext;
					foreach (List<int> list6 in array)
					{
						for (int m = 0; m + 2 < list6.Count; m += 3)
						{
							list4.Add(list6[m]);
							list4.Add(list6[m + 1]);
							list4.Add(list6[m + 2]);
							list4.Add(num + list6[m]);
							list4.Add(num + list6[m + 2]);
							list4.Add(num + list6[m + 1]);
						}
					}
					job.phShell += Stopwatch.GetTimestamp() - timestamp2;
				}
				if (list2.Count >= 4)
				{
					long timestamp3 = Stopwatch.GetTimestamp();
					ringDup = new Dictionary<int, int>();
					foreach (List<int> item3 in ClusterCapLoops(SplitCapLoops(list2), (int g) => bindPos[g]))
					{
						if (item3.Count < 4)
						{
							continue;
						}
						Vector3 val3 = Vector3.zero;
						HashSet<int> hashSet = new HashSet<int>();
						foreach (int item4 in item3)
						{
							if (hashSet.Add(item4))
							{
								val3 += bindPos[item4];
							}
						}
						val3 /= (float)hashSet.Count;
						float num5 = 0f;
						foreach (int item5 in hashSet)
						{
							float num6 = num5;
							val4 = bindPos[item5] - val3;
							num5 = num6 + ((Vector3)(ref val4)).magnitude;
						}
						num5 /= (float)hashSet.Count;
						for (int num7 = 0; num7 + 1 < item3.Count; num7 += 2)
						{
							float num8 = num3;
							val4 = bindPos[item3[num7]] - bindPos[item3[num7 + 1]];
							num3 = num8 + ((Vector3)(ref val4)).magnitude;
						}
						Vector3 val5 = Vector3.zero;
						for (int num9 = 0; num9 + 1 < item3.Count; num9 += 2)
						{
							val5 += Vector3.Cross(bindPos[item3[num9]] - val3, bindPos[item3[num9 + 1]] - val3);
						}
						val5 = ((((Vector3)(ref val5)).sqrMagnitude > 1E-10f) ? ((Vector3)(ref val5)).normalized : Vector3.up);
						BoneWeight val6 = weights[item3[0]];
						int count = pos.Count;
						pos.Add(val3);
						nrm.Add(val5);
						wts.Add(val6);
						pos.Add(val3);
						nrm.Add(-val5);
						wts.Add(val6);
						for (int num10 = 0; num10 + 1 < item3.Count; num10 += 2)
						{
							int num11 = RingVert(item3[num10], val5);
							int num12 = RingVert(item3[num10 + 1], val5);
							if (Vector3.Dot(Vector3.Cross(pos[num11] - val3, pos[num12] - val3), val5) < 0f)
							{
								int num13 = num11;
								num11 = num12;
								num12 = num13;
							}
							list4.Add(count);
							list4.Add(num11);
							list4.Add(num12);
							list4.Add(count + 1);
							list4.Add(num12 + 1);
							list4.Add(num11 + 1);
						}
						if (list == null || job.boneSpots == null || job.skin == null || !(num5 > 0.0001f))
						{
							continue;
						}
						int boneIndex = ((BoneWeight)(ref val6)).boneIndex0;
						Matrix4x4 val7 = ((boneIndex >= 0 && boneIndex < job.skin.Length) ? job.skin[boneIndex] : job.skinFallback);
						Vector3 val8 = ((Matrix4x4)(ref val7)).MultiplyPoint3x4(val3);
						float num14 = num5 / Mathf.Max(bindPerWorld, 0.001f);
						bool flag3 = false;
						foreach (Vector3 boneSpot in job.boneSpots)
						{
							val4 = boneSpot - val8;
							if (((Vector3)(ref val4)).magnitude < num14 * 0.6f)
							{
								flag3 = true;
								break;
							}
						}
						if (flag3)
						{
							AddDisc(pos, nrm, null, wts, list, val3, val5, Mathf.Min(num5 * 0.3f, 0.35f * bindPerWorld), 0.012f * bindPerWorld, val6);
						}
					}
					job.phCaps += Stopwatch.GetTimestamp() - timestamp3;
				}
			}
			else
			{
				for (int num15 = 0; num15 < num; num15++)
				{
					pos.Add(bindPos[num15]);
					wts.Add(weights[num15]);
				}
				array = ext;
				foreach (List<int> list7 in array)
				{
					for (int num16 = 0; num16 + 2 < list7.Count; num16 += 3)
					{
						list4.Add(list7[num16]);
						list4.Add(list7[num16 + 1]);
						list4.Add(list7[num16 + 2]);
						list4.Add(list7[num16]);
						list4.Add(list7[num16 + 2]);
						list4.Add(list7[num16 + 1]);
					}
				}
				if (list2.Count >= 4)
				{
					foreach (List<int> item6 in ClusterCapLoops(SplitCapLoops(list2), (int g) => bindPos[g]))
					{
						if (item6.Count < 4)
						{
							continue;
						}
						Vector3 val9 = Vector3.zero;
						HashSet<int> hashSet2 = new HashSet<int>();
						foreach (int item7 in item6)
						{
							if (hashSet2.Add(item7))
							{
								val9 += bindPos[item7];
							}
						}
						val9 /= (float)hashSet2.Count;
						for (int num17 = 0; num17 + 1 < item6.Count; num17 += 2)
						{
							float num18 = num3;
							val4 = bindPos[item6[num17]] - bindPos[item6[num17 + 1]];
							num3 = num18 + ((Vector3)(ref val4)).magnitude;
						}
						int count2 = pos.Count;
						pos.Add(val9);
						wts.Add(weights[item6[0]]);
						for (int num19 = 0; num19 + 1 < item6.Count; num19 += 2)
						{
							int item = item6[num19];
							int item2 = item6[num19 + 1];
							list4.Add(count2);
							list4.Add(item);
							list4.Add(item2);
							list4.Add(count2);
							list4.Add(item2);
							list4.Add(item);
						}
					}
				}
			}
			FlattenSkinWeights((int index) => wts[index], wts.Count, out job.bwPerVert, out job.bwFlat, out job.bwFlatCount);
			job.pos = pos;
			job.nrm = nrm;
			job.tris = list4;
			job.boneTris = list;
			job.woundLen = num3;
			job.computeTicks = Stopwatch.GetTimestamp() - timestamp;
			int RingVert(int g, Vector3 axis)
			{
				//IL_0038: 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_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: 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_009a: Unknown result type (might be due to invalid IL or missing references)
				if (ringDup.TryGetValue(g, out var value))
				{
					return value;
				}
				value = pos.Count;
				ringDup[g] = value;
				pos.Add(bindPos[g]);
				nrm.Add(axis);
				wts.Add(weights[g]);
				pos.Add(bindPos[g]);
				nrm.Add(-axis);
				wts.Add(weights[g]);
				return value;
			}
		}

		private static void ApplyInnards(InnardsJob job)
		{
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Expected O, but got Unknown
			Rend rend = job.rend;
			try
			{
				if (job.error != null)
				{
					GoreSystem.WarnThrottled("GoreSkeleton innards", job.error);
				}
				else
				{
					if ((Object)(object)job.c.modelTf == (Object)null || rend.dead || (Object)(object)rend.smr == (Object)null || !byModel.TryGetValue(job.c.modelTf, out var value) || value != job.c)
					{
						return;
					}
					if (!job.anyCore)
					{
						if ((Object)(object)rend.innardsGo != (Object)null)
						{
							SkinnedMeshRenderer component = rend.innardsGo.GetComponent<SkinnedMeshRenderer>();
							if ((Object)(object)component != (Object)null)
							{
								component.sharedMesh = null;
							}
							if ((Object)(object)rend.innardsMesh != (Object)null)
							{
								Object.Destroy((Object)(object)rend.innardsMesh);
							}
							rend.innardsMesh = null;
						}
						return;
					}
					Material val = GoreSystem.FleshMaterial(job.c.palette);
					if ((Object)(object)val == (Object)null)
					{
						return;
					}
					Material val2 = GoreSystem.BoneMaterial(job.c.palette);
					bool flag = job.boneTris != null && job.boneTris.Count > 0 && (Object)(object)val2 != (Object)null;
					long timestamp = Stopwatch.GetTimestamp();
					Mesh val3 = rend.innardsMesh;
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = new Mesh
						{
							name = "goreinnards"
						};
						val3.MarkDynamic();
						rend.innardsMesh = val3;
					}
					else
					{
						val3.Clear();
					}
					val3.indexFormat = (IndexFormat)(job.pos.Count > 65535);
					val3.SetVertices(job.pos);
					if (job.nrm != null)
					{
						val3.SetNormals(job.nrm);
					}
					ApplySkinWeightsFlat(val3, job.bwPerVert, job.bwFlat, job.bwFlatCount);
					val3.bindposes = rend.bindposes;
					val3.subMeshCount = ((!flag) ? 1 : 2);
					val3.SetTriangles(job.tris, 0, false, 0);
					if (flag)
					{
						val3.SetTriangles(job.boneTris, 1, false, 0);
					}
					val3.bounds = (Bounds)(((Object)(object)rend.smr.sharedMesh != (Object)null) ? rend.smr.sharedMesh.bounds : new Bounds(Vector3.zero, Vector3.one));
					if ((Object)(object)rend.innardsGo == (Object)null)
					{
						rend.innardsGo = new GameObject("goreinnards");
						rend.innardsGo.transform.SetParent(((Component)rend.smr).transform, false);
						SkinnedMeshRenderer obj = rend.innardsGo.AddComponent<SkinnedMeshRenderer>();
						obj.bones = rend.bones;
						obj.rootBone = rend.smr.rootBone;
						obj.updateWhenOffscreen = true;
						((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
					}
					SkinnedMeshRenderer component2 = rend.innardsGo.GetComponent<SkinnedMeshRenderer>();
					component2.sharedMesh = null;
					component2.sharedMesh = val3;
					((Renderer)component2).sharedMaterials = (Material[])(object)((!flag) ? new Material[1] { val } : new Material[2] { val, val2 });
					float num = job.woundLen / Mathf.Max(job.bindPerWorld, 0.001f);
					float num2 = Mathf.Clamp(0.6f + num * 0.5f, 0.6f, 3f);
					float num3 = Mathf.Clamp(4f * (0.4f + num * 0.35f), 2f, 10f);
					DripSource dripSource = null;
					foreach (DripSource dripper in drippers)
					{
						if ((object)dripper.cap == component2)
						{
							dripSource = dripper;
							break;
						}
					}
					if (dripSource == null)
					{
						dripSource = new DripSource
						{
							cap = (Renderer)(object)component2,
							palette = job.c.palette
						};
						drippers.Add(dripSource);
					}
					dripSource.strength = Mathf.Max(dripSource.strength, num2);
					dripSource.until = Time.time + num3;
					dripSource.next = Time.time + 0.2f;
					if (ModOptions.TestButtons.Value)
					{
						double num4 = PhaseMs(Stopwatch.GetTimestamp() - timestamp);
						double num5 = PhaseMs(job.computeTicks);
						if (num4 >= 15.0 || num5 >= 25.0)
						{
							ManualLogSource log = ScorchedVoxelsPlugin.Log;
							string[] obj2 = new string[6] { "[gore timing] innards ", null, null, null, null, null };
							Transform modelTf = job.c.modelTf;
							obj2[1] = ((modelTf != null) ? ((Object)modelTf).name : null);
							obj2[2] = ":";
							obj2[3] = $" apply {num4:F1}ms + compute {num5:F1}ms off-thread";
							obj2[4] = $" — edges {PhaseMs(job.phEdges):F1} shell {PhaseMs(job.phShell):F1}";
							obj2[5] = $" caps {PhaseMs(job.phCaps):F1} (tris {job.extTris})";
							log.LogInfo((object)string.Concat(obj2));
						}
					}
				}
			}
			finally
			{
				rend.innardsBusy = false;
			}
		}

		internal static bool LiveBite(CharacterBody body, Vector3 pos, Vector3 force, float frac, bool fromWire = false)
		{
			//IL_017e: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: 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_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			if (!GoreSystem.Active || !VoxelTerrainManager.LocalConversionDone)
			{
				return false;
			}
			if ((Object)(object)body == (Object)null || (Object)(object)body.healthComponent == (Object)null || !body.healthComponent.alive)
			{
				return false;
			}
			if (body.isPlayerControlled)
			{
				return false;
			}
			Transform val = (((Object)(object)body.modelLocator != (Object)null) ? body.modelLocator.modelTransform : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!byModel.TryGetValue(val, out var value))
			{
				int num = 0;
				foreach (Corpse corpse in corpses)
				{
					if (corpse.alive)
					{
						num++;
					}
				}
				if (num >= 12)
				{
					return false;
				}
				value = RegisterLive(val, GoreSystem.PaletteForBody(body));
				if (value == null)
				{
					return false;
				}
			}
			if (!value.alive)
			{
				return false;
			}
			float time = Time.time;
			if (!fromWire)
			{
				if (value.liveBites >= 3 || time < value.nextLiveBiteAt)
				{
					return false;
				}
				if (GlobalQueueFull)
				{
					return false;
				}
			}
			if (value.cuts >= 16 || value.queued >= 5)
			{
				return false;
			}
			value.liveBites++;
			value.nextLiveBiteAt = time + 0.5f;
			if (!NetworkClient.active)
			{
				return true;
			}
			float num2 = Mathf.Clamp(value.radius * (0.16f + 0.14f * Mathf.Min(frac, 1f)), 0.18f, 2.2f);
			Vector3 dir = ((((Vector3)(ref force)).sqrMagnitude > 0.01f) ? ((Vector3)(ref force)).normalized : Vector3.up);
			Enqueue(new CutReq
			{
				c = value,
				shape = 1,
				style = 8,
				pos = pos,
				dir = dir,
				radius = num2,
				boost = 0.6f
			}, fromWire);
			GoreSystem.BulletSpray(pos, dir, value.palette);
			GoreSystem.BulletSpray(pos + RandomInSphere() * (num2 * 0.4f), dir, value.palette);
			return true;
		}

		private static Corpse RegisterLive(Transform modelTf, int palette)
		{
			if (liveDeclined.Contains(modelTf))
			{
				return null;
			}
			Corpse corpse = Register(modelTf, palette);
			if (corpse == null)
			{
				return null;
			}
			if (corpse.rends.Count == 0)
			{
				corpses.Remove(corpse);
				byModel.Remove(modelTf);
				liveDeclined.Add(modelTf);
				return null;
			}
			corpse.alive = true;
			corpse.expireAt = float.PositiveInfinity;
			return corpse;
		}

		private static void PromoteLiveCorpse(Corpse c)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			c.alive = false;
			c.expireAt = (c.bornAt = Time.time) + 120f;
			bool flag = false;
			Bounds val = default(Bounds);
			foreach (Rend rend in c.rends)
			{
				if (!((Object)(object)rend.smr == (Object)null))
				{
					if (!flag)
					{
						val = ((Renderer)rend.smr).bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref val)).Encapsulate(((Renderer)rend.smr).bounds);
					}
				}
			}
			if (flag)
			{
				c.center = ((Bounds)(ref val)).center;
				c.boundsSize = ((Bounds)(ref val)).size;
				Vector3 extents = ((Bounds)(ref val)).extents;
				c.radius = ((Vector3)(ref extents)).magnitude;
			}
		}

		private static List<List<int>> SplitCapLoops(List<int> capEdges)
		{
			Dictionary<int, int> root = new Dictionary<int, int>();
			foreach (int capEdge in capEdges)
			{
				if (!root.ContainsKey(capEdge))
				{
					root[capEdge] = capEdge;
				}
			}
			for (int i = 0; i + 1 < capEdges.Count; i += 2)
			{
				int num = Find(capEdges[i]);
				int num2 = Find(capEdges[i + 1]);
				if (num != num2)
				{
					root[num] = num2;
				}
			}
			Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
			List<List<int>> list = new List<List<int>>();
			for (int j = 0; j + 1 < capEdges.Count; j += 2)
			{
				int key = Find(capEdges[j]);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = (dictionary[key] = new List<int>());
					list.Add(value);
				}
				value.Add(capEdges[j]);
				value.Add(capEdges[j + 1]);
			}
			return list;
			int Find(int x)
			{
				while (root[x] != x)
				{
					root[x] = root[root[x]];
					x = root[x];
				}
				return x;
			}
		}

		private static List<List<int>> ClusterCapLoops(List<List<int>> loops, Func<int, Vector3> at)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			int count = loops.Count;
			if (count <= 1)
			{
				return loops;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[count];
			float[] array2 = new float[count];
			Vector3 val2;
			for (int i = 0; i < count; i++)
			{
				Vector3 val = Vector3.zero;
				HashSet<int> hashSet = new HashSet<int>();
				foreach (int item in loops[i])
				{
					if (hashSet.Add(item))
					{
						val += at(item);
					}
				}
				val /= (float)hashSet.Count;
				float num = 0f;
				foreach (int item2 in hashSet)
				{
					float num2 = num;
					val2 = at(item2) - val;
					num = num2 + ((Vector3)(ref val2)).magnitude;
				}
				array[i] = val;
				array2[i] = num / (float)hashSet.Count;
			}
			int[] root = new int[count];
			for (int j = 0; j < count; j++)
			{
				root[j] = j;
			}
			for (int k = 0; k < count; k++)
			{
				for (int l = k + 1; l < count; l++)
				{
					val2 = array[k] - array[l];
					if (((Vector3)(ref val2)).magnitude < (array2[k] + array2[l]) * 1.2f + 0.05f)
					{
						int num3 = Find(k);
						int num4 = Find(l);
						if (num3 != num4)
						{
							root[num3] = num4;
						}
					}
				}
			}
			Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
			List<List<int>> list = new List<List<int>>();
			for (int m = 0; m < count; m++)
			{
				int key = Find(m);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = (dictionary[key] = new List<int>());
					list.Add(value);
				}
				value.AddRange(loops[m]);
			}
			return list;
			int Find(int x)
			{
				while (root[x] != x)
				{
					root[x] = root[root[x]];
					x = root[x];
				}
				return x;
			}
		}

		private static void AddDisc(List<Vector3> pos, List<Vector3> nrm, List<Vector2> uv, List<BoneWeight> wts, List<int> tris, Vector3 center, Vector3 axis, float radius, float lift, BoneWeight weight)
		{
			//IL_0000: 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)
			//IL_0013: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_00aa: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00dd: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Mathf.Abs(axis.y) < 0.8f) ? Vector3.up : Vector3.forward);
			Vector3 val2 = Vector3.Normalize(Vector3.Cross(axis, val));
			Vector3 val3 = Vector3.Cross(axis, val2);
			for (int i = 0; i < 2; i++)
			{
				Vector3 val4 = ((i == 0) ? axis : (-axis));
				Vector3 val5 = center + val4 * lift;
				int count = pos.Count;
				pos.Add(val5);
				nrm.Add(val4);
				uv?.Add(Vector2.zero);
				wts?.Add(weight);
				int count2 = pos.Count;
				for (int j = 0; j < 10; j++)
				{
					float num = (float)j * (MathF.PI / 5f);
					pos.Add(val5 + (val2 * Mathf.Cos(num) + val3 * Mathf.Sin(num)) * radius);
					nrm.Add(val4);
					uv?.Add(Vector2.zero);
					wts?.Add(weight);
				}
				for (int k = 0; k < 10; k++)
				{
					int item = count2 + k;
					int item2 = count2 + (k + 1) % 10;
					if (i == 0)
					{
						tris.Add(count);
						tris.Add(item);
						tris.Add(item2);
					}
					else
					{
						tris.Add(count);
						tris.Add(item2);
						tris.Add(item);
					}
				}
			}
		}

		private static void AppendFleshShell(List<Vector3> pos, List<Vector3> nrm, List<Vector2> uv, List<int>[] skinTris, List<int> fleshTris, List<int> capEdges, Vector3 capDir, List<Vector3> boneSpots = null, List<int> boneTris = null)
		{
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: 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_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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: 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_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_058a: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_0646: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_0699: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			int count = pos.Count;
			int num = 0;
			List<int>[] array = skinTris;
			foreach (List<int> list in array)
			{
				num += list.Count / 3;
			}
			if (num <= 4000)
			{
				Vector3[] array2 = (Vector3[])(object)new Vector3[count];
				array = skinTris;
				foreach (List<int> list2 in array)
				{
					for (int j = 0; j + 2 < list2.Count; j += 3)
					{
						Vector3 val = Vector3.Cross(pos[list2[j + 1]] - pos[list2[j]], pos[list2[j + 2]] - pos[list2[j]]);
						ref Vector3 reference = ref array2[list2[j]];
						reference += val;
						ref Vector3 reference2 = ref array2[list2[j + 1]];
						reference2 += val;
						ref Vector3 reference3 = ref array2[list2[j + 2]];
						reference3 += val;
					}
				}
				for (int k = 0; k < count; k++)
				{
					Vector3 val2 = ((Vector3.Dot(nrm[k], array2[k]) < 0f) ? (-nrm[k]) : nrm[k]);
					pos.Add(pos[k] - val2 * 0.008f);
					nrm.Add(val2);
					uv.Add(Vector2.zero);
				}
				for (int l = 0; l < count; l++)
				{
					pos.Add(pos[count + l]);
					nrm.Add(-nrm[count + l]);
					uv.Add(Vector2.zero);
				}
				array = skinTris;
				foreach (List<int> list3 in array)
				{
					for (int m = 0; m + 2 < list3.Count; m += 3)
					{
						int num2 = count + list3[m];
						int num3 = count + list3[m + 1];
						int num4 = count + list3[m + 2];
						fleshTris.Add(num2);
						fleshTris.Add(num3);
						fleshTris.Add(num4);
						num2 += count;
						num3 += count;
						num4 += count;
						fleshTris.Add(num2);
						fleshTris.Add(num4);
						fleshTris.Add(num3);
					}
				}
			}
			if (capEdges == null || capEdges.Count < 4)
			{
				return;
			}
			if (((Vector3)(ref capDir)).sqrMagnitude < 1E-06f)
			{
				capDir = Vector3.up;
			}
			((Vector3)(ref capDir)).Normalize();
			Dictionary<int, int> capRing = new Dictionary<int, int>();
			foreach (List<int> item in ClusterCapLoops(SplitCapLoops(capEdges), (int li) => pos[li]))
			{
				if (item.Count < 4)
				{
					continue;
				}
				Vector3 val3 = Vector3.zero;
				HashSet<int> hashSet = new HashSet<int>();
				foreach (int item2 in item)
				{
					if (hashSet.Add(item2))
					{
						val3 += pos[item2];
					}
				}
				val3 /= (float)hashSet.Count;
				float num5 = 0f;
				Vector3 val4;
				foreach (int item3 in hashSet)
				{
					float num6 = num5;
					val4 = pos[item3] - val3;
					num5 = num6 + ((Vector3)(ref val4)).magnitude;
				}
				num5 /= (float)hashSet.Count;
				Vector3 val5 = Vector3.zero;
				for (int num7 = 0; num7 + 1 < item.Count; num7 += 2)
				{
					val5 += Vector3.Cross(pos[item[num7]] - val3, pos[item[num7 + 1]] - val3);
				}
				val5 = ((((Vector3)(ref val5)).sqrMagnitude > 1E-10f) ? ((Vector3)(ref val5)).normalized : capDir);
				int count2 = pos.Count;
				pos.Add(val3);
				nrm.Add(val5);
				uv.Add(Vector2.zero);
				pos.Add(val3);
				nrm.Add(-val5);
				uv.Add(Vector2.zero);
				for (int num8 = 0; num8 + 1 < item.Count; num8 += 2)
				{
					int num9 = RingVert(item[num8], val5);
					int num10 = RingVert(item[num8 + 1], val5);
					if (Vector3.Dot(Vector3.Cross(pos[num9] - val3, pos[num10] - val3), val5) < 0f)
					{
						int num11 = num9;
						num9 = num10;
						num10 = num11;
					}
					fleshTris.Add(count2);
					fleshTris.Add(num9);
					fleshTris.Add(num10);
					fleshTris.Add(count2 + 1);
					fleshTris.Add(num10 + 1);
					fleshTris.Add(num9 + 1);
				}
				if (boneTris == null || boneSpots == null || !(num5 > 0.0001f))
				{
					continue;
				}
				bool flag = false;
				foreach (Vector3 boneSpot in boneSpots)
				{
					val4 = boneSpot - val3;
					if (((Vector3)(ref val4)).magnitude < num5 * 0.6f)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					AddDisc(pos, nrm, uv, null, boneTris, val3, val5, Mathf.Min(num5 * 0.3f, 0.35f), 0.012f, default(BoneWeight));
				}
			}
			int RingVert(int li, Vector3 axis)
			{
				//IL_0038: 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_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: 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)
				if (capRing.TryGetValue(li, out var value))
				{
					return value;
				}
				value = pos.Count;
				capRing[li] = value;
				pos.Add(pos[li]);
				nrm.Add(axis);
				uv.Add(Vector2.zero);
				pos.Add(pos[li]);
				nrm.Add(-axis);
				uv.Add(Vector2.zero);
				return value;
			}
		}

		private static bool TakePieceBudget()
		{
			float time = Time.time;
			if (time - pieceWindowStart >= 1f)
			{
				pieceWindowStart = time;
				pieceWindowCount = 0;
			}
			if (pieceWindowCount >= 24)
			{
				return false;
			}
			pieceWindowCount++;
			return true;
		}

		private static PiecePrep PrepPiece(CutJob job, PieceGeo geo)
		{
			//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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: 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)
			PiecePrep piecePrep = new PiecePrep
			{
				geo = geo,
				center = ((Bounds)(ref geo.bounds)).center,
				nOuter = geo.pos.Count
			};
			List<int>[] tris = geo.tris;
			foreach (List<int> list in tris)
			{
				job.ppTris += list.Count / 3;
			}
			long timestamp = Stopwatch.GetTimestamp();
			piecePrep.capEdges = BoundaryEdges(geo.tris, BuildCanon(geo.pos, piecePrep.nOuter));
			job.ppEdges += Stopwatch.GetTimestamp() - timestamp;
			for (int j = 0; j + 1 < piecePrep.capEdges.Count; j += 2)
			{
				float capLen = piecePrep.capLen;
				Vector3 val = geo.pos[piecePrep.capEdges[j]] - geo.pos[piecePrep.capEdges[j + 1]];
				piecePrep.capLen = capLen + ((Vector3)(ref val)).magnitude;
			}
			if (job.wantFlesh)
			{
				piecePrep.fleshTris = new List<int>();
				piecePrep.boneTris = (job.wantBone ? new List<int>() : null);
				Vector3 capDir = ((job.req.shape == 0) ? job.req.dir : (((Bounds)(ref geo.bounds)).center - job.req.pos));
				timestamp = Stopwatch.GetTimestamp();
				AppendFleshShell(geo.pos, geo.nrm, geo.uv, geo.tris, piecePrep.fleshTris, piecePrep.capEdges, capDir, geo.boneSpots, piecePrep.boneTris);
				job.ppShell += Stopwatch.GetTimestamp() - timestamp;
			}
			piecePrep.local = (Vector3[])(object)new Vector3[geo.pos.Count];
			for (int k = 0; k < piecePrep.local.Length; k++)
			{
				piecePrep.local[k] = geo.pos[k] - piecePrep.center;
			}
			return piecePrep;
		}

		private static bool SpawnPiecePrepared(Corpse c, PiecePrep prep, CutReq req)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_057d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0582: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_056b: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0642: Unknown result type (might be due to invalid IL or missing references)
			//IL_0646: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0650: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Unknown result type (might be due to invalid IL or missing references)
			//IL_066b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0670: Unknown result type (might be due to invalid IL or missing references)
			//IL_067c: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0737: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0807: Unknown result type (might be due to invalid IL or missing references)
			//IL_080c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0839: Unknown result type (might be due to invalid IL or missing references)
			//IL_083e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0850: Unknown result type (might be due to invalid IL or missing references)
			//IL_0855: Unknown result type (might be due to invalid IL or missing references)
			if (!TakePieceBudget())
			{
				return false;
			}
			if ((Object)(object)pieceRoot == (Object)null)
			{
				pieceRoot = new GameObject("ScorchedVoxelsPieces");
			}
			PieceGeo geo = prep.geo;
			Vector3 center = prep.center;
			float capLen = prep.capLen;
			int nOuter = prep.nOuter;
			Material val = GoreSystem.FleshMaterial(c.palette);
			List<int> list = (((Object)(object)val != (Object)null) ? prep.fleshTris : null);
			Material val2 = (((Object)(object)val != (Object)null) ? GoreSystem.BoneMaterial(c.palette) : null);
			List<int> list2 = (((Object)(object)val2 != (Object)null) ? prep.boneTris : null);
			bool flag = list2 != null && list2.Count > 0;
			Mesh val3 = new Mesh
			{
				name = "gorepiece"
			};
			if (geo.pos.Count > 65535)
			{
				val3.indexFormat = (IndexFormat)1;
			}
			val3.vertices = prep.local;
			val3.normals = geo.nrm.ToArray();
			val3.uv = geo.uv.ToArray();
			int num = geo.tris.Length;
			val3.subMeshCount = num + ((list != null) ? 1 : 0) + (flag ? 1 : 0);
			List<int> list3 = new List<int>();
			for (int i = 0; i < num; i++)
			{
				List<int> list4 = geo.tris[i];
				if (list != null)
				{
					val3.SetTriangles(list4, i, false, 0);
					continue;
				}
				list3.Clear();
				list3.AddRange(list4);
				for (int j = 0; j + 2 < list4.Count; j += 3)
				{
					list3.Add(list4[j]);
					list3.Add(list4[j + 2]);
					list3.Add(list4[j + 1]);
				}
				val3.SetTriangles(list3, i, false, 0);
			}
			if (list != null)
			{
				val3.SetTriangles(list, num, false, 0);
			}
			if (flag)
			{
				val3.SetTriangles(list2, num + 1, false, 0);
			}
			Bounds bounds = geo.bounds;
			((Bounds)(ref bounds)).center = Vector3.zero;
			((Bounds)(ref bounds)).Expand(0.05f);
			val3.bounds = bounds;
			GameObject val4 = new GameObject("gorepiece");
			val4.transform.SetParent(pieceRoot.transform, false);
			val4.transform.position = center;
			val4.layer = LayerIndex.debris.intVal;
			MeshFilter val5 = val4.AddComponent<MeshFilter>();
			val5.sharedMesh = val3;
			MeshRenderer val6 = val4.AddComponent<MeshRenderer>();
			Material[] sharedMaterials = ((Renderer)geo.rend.smr).sharedMaterials;
			Material[] array = (Material[])(object)new Material[num + ((list != null) ? 1 : 0) + (flag ? 1 : 0)];
			for (int k = 0; k < num; k++)
			{
				array[k] = ((k < sharedMaterials.Length) ? sharedMaterials[k] : ((sharedMaterials.Length != 0) ? sharedMaterials[^1] : null));
				if ((Object)(object)array[k] == (Object)null || ((Object)array[k]).name.EndsWith("(Instance)"))
				{
					array[k] = val;
				}
			}
			if (list != null)
			{
				array[num] = val;
			}
			if (flag)
			{
				array[num + 1] = val2;
			}
			((Renderer)val6).sharedMaterials = array;
			((Renderer)val6).shadowCastingMode = (ShadowCastingMode)1;
			Rigidbody val7 = val4.AddComponent<Rigidbody>();
			val7.drag = 0.05f;
			val7.angularDrag = 0.05f;
			val7.maxDepenetrationVelocity = 1.2f;
			val7.sleepThreshold = 0.05f;
			val7.solverIterations = 2;
			val7.solverVelocityIterations = 1;
			float num2 = Mathf.Max(((Bounds)(ref geo.bounds)).size.x * ((Bounds)(ref geo.bounds)).size.y * ((Bounds)(ref geo.bounds)).size.z, 0.001f);
			val7.mass = Mathf.Clamp(num2 * 160f, 1.5f, 180f);
			Vector3 val10;
			Vector3 val9;
			float num3;
			switch (req.style)
			{
			case 0:
			case 3:
			{
				float num5 = Mathf.Sign(Vector3.Dot(center - req.pos, req.dir));
				val10 = req.dir * num5 + Vector3.up * 0.6f;
				val9 = ((Vector3)(ref val10)).normalized;
				num3 = ((req.style == 3) ? 4f : 3f);
				break;
			}
			case 6:
			{
				float num4 = Mathf.Sign(Vector3.Dot(center - req.pos, req.dir));
				val10 = req.dir * num4 + Vector3.up * 0.5f;
				val9 = ((Vector3)(ref val10)).normalized;
				num3 = 2.1f;
				break;
			}
			case 5:
				val10 = RandomInSphere() * 0.4f + Vector3.up * 0.15f;
				val9 = ((Vector3)(ref val10)).normalized;
				num3 = 0.9f;
				break;
			case 7:
			{
				Vector3 val11 = req.pos - center;
				float magnitude2 = ((Vector3)(ref val11)).magnitude;
				val9 = ((magnitude2 > 0.01f) ? (val11 / magnitude2) : Vector3.up);
				num3 = Mathf.Clamp(9f / (0.5f + magnitude2), 4f, 9f);
				break;
			}
			case 8:
				val10 = req.dir + Vector3.up * 0.35f;
				val9 = ((Vector3)(ref val10)).normalized;
				num3 = 3.2f;
				break;
			default:
			{
				Vector3 val8 = center - req.pos;
				float magnitude = ((Vector3)(ref val8)).magnitude;
				val9 = ((magnitude > 0.01f) ? (val8 / magnitude) : Vector3.up);
				num3 = Mathf.Clamp(22f / (1f + magnitude), 7f, 20f);
				if (req.style == 4)
				{
					num3 *= 0.7f;
				}
				break;
			}
			}
			float num6 = ((req.boost > 0f) ? req.boost : 1f);
			num3 *= num6;
			bool flag2 = req.style == 1 || req.style == 4;
			float num7 = (flag2 ? 2.2f : ((req.style == 5) ? 0.1f : 1.2f)) * num6;
			val7.velocity = CorpseVelocity(c, center) + val9 * num3 + Vector3.up * num7 + RandomInSphere() * 0.8f;
			val7.angularVelocity = RandomInSphere() * (flag2 ? 6f : (3f + (float)rng.NextDouble() * 7f));
			float time = Time.time;
			Piece piece = new Piece
			{
				skinVerts = ((prep.fleshTris != null) ? nOuter : geo.pos.Count),
				skinSubs = num,
				go = val4,
				tf = val4.transform,
				mesh = val3,
				mf = val5,
				mr = val6,
				palette = c.palette,
				dieAt = time + 12f + (float)rng.NextDouble() * 3f,
				killY = center.y - 250f,
				dribbleUntil = time + 2.2f * (0.6f + Mathf.Min(capLen, 4f) * 0.35f),
				nextDribble = time + 0.11f,
				born = time,
				dripPalette = c.palette,
				rb = val7
			};
			DressPiece(piece, c, req);
			GoreGib goreGib = val4.AddComponent<GoreGib>();
			goreGib.paletteIdx = piece.dripPalette;
			goreGib.splatBudget = 10;
			if (pieces.Count >= 32)
			{
				DestroyPiece(0);
			}
			pieces.Add(piece);
			BakeHullAsync(piece, val3);
			Vector3 pos = ((Bounds)(ref geo.bounds)).ClosestPoint(req.pos);
			Vector3 dir = val9;
			int dripPalette = piece.dripPalette;
			val10 = ((Bounds)(ref geo.bounds)).size;
			GoreSystem.CutSpray(pos, dir, dripPalette, Mathf.Clamp(((Vector3)(ref val10)).magnitude, 0.5f, 2.5f));
			if (req.style != 6)
			{
				Vector3 val12 = ((Bounds)(ref geo.bounds)).ClosestPoint(req.pos);
				Transform transform = val4.transform;
				val10 = ((Bounds)(ref geo.bounds)).extents;
				GoreSystem.SinewSnap(val12, transform, ((Vector3)(ref val10)).magnitude, piece.dripPalette);
			}
			return true;
		}

		private static void CutPiecesNear(byte shape, byte style, Vector3 pos, Vector3 dir, float radius, float reach)
		{
			//IL_008e: 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_0097: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00d5: 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)
			long t = GoreProf.Begin();
			int num = 3;
			float time = Time.time;
			recutScratch.Clear();
			recutScratch.AddRange(pieces);
			int num2 = recutScratch.Count - 1;
			while (num2 >= 0 && num > 0)
			{
				Piece piece = recutScratch[num2];
				if (!((Object)(object)piece.go == (Object)null) && !((Object)(object)piece.mesh == (Object)null) && piece.cuts < 2 && !(piece.dieAt - time < 1f))
				{
					Bounds bounds = piece.mesh.bounds;
					Vector3 val = ((Bounds)(ref bounds)).extents;
					float magnitude = ((Vector3)(ref val)).magnitude;
					float num3 = reach + magnitude;
					val = piece.tf.position - pos;
					if (!(((Vector3)(ref val)).sqrMagnitude > num3 * num3))
					{
						try
						{
							if (CutPieceGeom(piece, shape, style, pos, dir, radius))
							{
								num--;
							}
						}
						catch (Exception arg)
						{
							ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreSkeleton piece recut failed: {arg}");
						}
					}
				}
				num2--;
			}
			GoreProf.End(44, t);
		}

		private static bool CutPieceGeom(Piece p, byte shape, byte style, Vector3 pos, Vector3 dir, float radius)
		{
			//IL_00d1: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: 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_02db: 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_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: Expected O, but got Unknown
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: 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_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: 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_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_078e: Unknown result type (might be due to invalid IL or missing references)
			//IL_079b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Unknown result type (might be due to invalid IL or missing references)
			Mesh mesh = p.mesh;
			int vertexCount = mesh.vertexCount;
			if (vertexCount < 12 || !mesh.isReadable)
			{
				return false;
			}
			int nSkin = ((p.skinVerts > 0) ? Mathf.Min(p.skinVerts, vertexCount) : vertexCount);
			int subMeshCount = mesh.subMeshCount;
			int num = ((p.skinSubs > 0) ? Mathf.Min(p.skinSubs, subMeshCount) : subMeshCount);
			bool flag = num < subMeshCount;
			if (nSkin < 12)
			{
				return false;
			}
			Vector3[] lp = mesh.vertices;
			Vector3[] normals = mesh.normals;
			Vector2[] uv = mesh.uv;
			Vector3[] ln = ((normals != null && normals.Length == vertexCount) ? normals : null);
			Vector2[] lu = ((uv != null && uv.Length == vertexCount) ? uv : null);
			if (flag && ln == null)
			{
				return false;
			}
			Matrix4x4 localToWorldMatrix = p.tf.localToWorldMatrix;
			Vector3[] array = (Vector3[])(object)new Vector3[nSkin];
			for (int i = 0; i < nSkin; i++)
			{
				array[i] = ((Matrix4x4)(ref localToWorldMatrix)).MultiplyPoint3x4(lp[i]);
			}
			int[] canon = BuildCanon(lp, nSkin);
			float[] array2 = new float[nSkin];
			bool flag2 = shape == 1;
			for (int j = 0; j < nSkin; j++)
			{
				float num2;
				if (!flag2)
				{
					num2 = Vector3.Dot(array[j] - pos, dir);
				}
				else
				{
					Vector3 val = array[j] - pos;
					num2 = ((Vector3)(ref val)).magnitude - radius;
				}
				float num3 = num2;
				array2[j] = ((Mathf.Abs(num3) < 0.0001f) ? 0.0001f : num3);
			}
			List<int>[] array3 = new List<int>[num];
			List<int>[] array4 = new List<int>[num];
			List<int>[] array5 = new List<int>[num];
			for (int k = 0; k < num; k++)
			{
				array3[k] = new List<int>(mesh.GetTriangles(k));
				array4[k] = new List<int>(array3[k].Count);
				array5[k] = new List<int>();
			}
			List<Vector3> addPos = new List<Vector3>();
			List<Vector3> addNrm = new List<Vector3>();
			List<Vector2> addUv = new List<Vector2>();
			Dictionary<long, int> lookup = new Dictionary<long, int>(EdgeKeyComparer.Instance);
			GoreCutCore.SplitVertFn splitAt = delegate(int lo, int hi, float s)
			{
				//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_005a: 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_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				long key = ((long)lo << 32) | (uint)hi;
				if (lookup.TryGetValue(key, out var value2))
				{
					return value2;
				}
				value2 = nSkin + addPos.Count;
				lookup[key] = value2;
				addPos.Add(Vector3.LerpUnclamped(lp[lo], lp[hi], s));
				addNrm.Add((ln != null) ? Vector3.Slerp(ln[lo], ln[hi], s) : Vector3.up);
				addUv.Add((lu != null) ? Vector2.LerpUnclamped(lu[lo], lu[hi], s) : Vector2.zero);
				return value2;
			};
			GoreCutCore.Classify(array2, array3, flag2, splitAt, array4, array5, out var dropped);
			if (flag2 && !dropped)
			{
				return false;
			}
			int num4 = CountIndices(array4);
			int num5 = CountIndices(array5);
			if (num5 == 0 && !dropped)
			{
				return false;
			}
			bool flag3 = true;
			if (flag2 && num5 > 0)
			{
				GoreCutCore.SphereKeep(array5, array4, -1, nSkin + addPos.Count, canon);
				num4 = CountIndices(array4);
				num5 = CountIndices(array5);
			}
			else if (!flag2 && num5 > num4)
			{
				List<int>[] array6 = array4;
				array4 = array5;
				array5 = array6;
				int num6 = num4;
				num4 = num5;
				num5 = num6;
				flag3 = false;
			}
			Vector3 val2 = (flag3 ? (-dir) : dir);
			if (num5 > 0)
			{
				List<List<int>[]> list = GoreCutCore.Components(array5, nSkin + addPos.Count, canon);
				list.Sort((List<int>[] a, List<int>[] b) => CountIndices(b).CompareTo(CountIndices(a)));
				int num7 = 0;
				foreach (List<int>[] item in list)
				{
					if (num7 >= 2)
					{
						break;
					}
					if (SpawnSubPiece(p, item, nSkin, array, localToWorldMatrix, lp, ln, lu, addPos, addNrm, addUv, flag, flag2 ? Vector3.zero : (-val2), style, pos, dir))
					{
						num7++;
					}
				}
			}
			if (num4 < 12)
			{
				DestroyPieceObject(p);
				return true;
			}
			List<Vector3> list2 = new List<Vector3>();
			List<Vector3> list3 = new List<Vector3>();
			List<Vector2> list4 = new List<Vector2>();
			Dictionary<int, int> dictionary = new Dictionary<int, int>(128);
			List<int>[] array7 = new List<int>[num];
			for (int num8 = 0; num8 < num; num8++)
			{
				List<int> list5 = array4[num8];
				array7[num8] = new List<int>(list5.Count);
				foreach (int item2 in list5)
				{
					if (!dictionary.TryGetValue(item2, out var value))
					{
						value = (dictionary[item2] = list2.Count);
						list2.Add((item2 < nSkin) ? lp[item2] : addPos[item2 - nSkin]);
						list3.Add((item2 >= nSkin) ? addNrm[item2 - nSkin] : ((ln != null) ? ln[item2] : Vector3.up));
						list4.Add((item2 >= nSkin) ? addUv[item2 - nSkin] : ((lu != null) ? lu[item2] : Vector2.zero));
					}
					array7[num8].Add(value);
				}
			}
			int count2 = list2.Count;
			List<int> list6 = null;
			if (flag)
			{
				list6 = new List<int>();
				List<int> capEdges = BoundaryEdges(array7, BuildCanon(list2, count2));
				List<int> fleshTris = list6;
				Vector3 capDir;
				if (!flag2)
				{
					Matrix4x4 inverse = ((Matrix4x4)(ref localToWorldMatrix)).inverse;
					capDir = ((Matrix4x4)(ref inverse)).MultiplyVector(val2);
				}
				else
				{
					capDir = Vector3.up;
				}
				AppendFleshShell(list2, list3, list4, array7, fleshTris, capEdges, capDir);
			}
			Mesh val3 = new Mesh
			{
				name = "gorepiece"
			};
			if (list2.Count > 65535)
			{
				val3.indexFormat = (IndexFormat)1;
			}
			val3.SetVertices(list2);
			if (ln != null)
			{
				val3.SetNormals(list3);
			}
			if (lu != null || flag)
			{
				val3.SetUVs(0, list4);
			}
			val3.subMeshCount = num + ((list6 != null) ? 1 : 0);
			for (int num9 = 0; num9 < num; num9++)
			{
				val3.SetTriangles(array7[num9], num9, false, 0);
			}
			if (list6 != null)
			{
				val3.SetTriangles(list6, num, false, 0);
			}
			Bounds bounds = default(Bounds);
			((Bounds)(ref bounds))..ctor(list2[0], Vector3.zero);
			for (int num10 = 1; num10 < list2.Count; num10++)
			{
				((Bounds)(ref bounds)).Encapsulate(list2[num10]);
			}
			((Bounds)(ref bounds)).Expand(0.05f);
			val3.bounds = bounds;
			p.mf.sharedMesh = val3;
			if ((Object)(object)p.mr != (Object)null && ((Renderer)p.mr).sharedMaterials.Length != val3.subMeshCount)
			{
				Material[] sharedMaterials = ((Renderer)p.mr).sharedMaterials;
				Material[] array8 = (Material[])(object)new Material[val3.subMeshCount];
				for (int num11 = 0; num11 < array8.Length; num11++)
				{
					array8[num11] = ((num11 < sharedMaterials.Length) ? sharedMaterials[num11] : ((sharedMaterials.Length != 0) ? sharedMaterials[^1] : null));
				}
				((Renderer)p.mr).sharedMaterials = array8;
			}
			if ((Object)(object)p.col != (Object)null)
			{
				p.col.sharedMesh = null;
			}
			Object.Destroy((Object)(object)p.mesh);
			p.mesh = val3;
			BakeHullAsync(p, val3);
			p.skinVerts = count2;
			p.skinSubs = num;
			p.cuts++;
			p.dribbleUntil = Time.time + 2.2f;
			p.nextDribble = Time.time + 0.11f;
			GoreSystem.CutSpray(p.tf.position, flag2 ? Vector3.up : dir, p.dripPalette, 0.8f);
			return true;
		}

		private static bool SpawnSubPiece(Piece parent, List<int>[] comp, int n, Vector3[] wv, Matrix4x4 m2w, Vector3[] lp, Vector3[] ln, Vector2[] lu, List<Vector3> addPos, List<Vector3> addNrm, List<Vector2> addUv, bool hasFlesh, Vector3 capDirWorld, byte style, Vector3 cutPos, Vector3 dir)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: 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_01f2: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_00fb: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Expected O, but got Unknown
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<int, int> dictionary = new Dictionary<int, int>(64);
			List<Vector3> list = new List<Vector3>();
			List<Vector3> list2 = new List<Vector3>();
			List<Vector2> list3 = new List<Vector2>();
			List<int>[] array = new List<int>[comp.Length];
			bool flag = false;
			Bounds val = default(Bounds);
			for (int i = 0; i < comp.Length; i++)
			{
				List<int> list4 = comp[i];
				array[i] = new List<int>(list4.Count);
				foreach (int item2 in list4)
				{
					if (!dictionary.TryGetValue(item2, out var value))
					{
						Vector3 val2 = ((item2 < n) ? wv[item2] : ((Matrix4x4)(ref m2w)).MultiplyPoint3x4(addPos[item2 - n]));
						Vector3 item = ((item2 >= n) ? ((Matrix4x4)(ref m2w)).MultiplyVector(addNrm[item2 - n]) : ((ln != null) ? ((Matrix4x4)(ref m2w)).MultiplyVector(ln[item2]) : Vector3.up));
						value = (dictionary[item2] = list.Count);
						list.Add(val2);
						list2.Add(item);
						list3.Add((item2 >= n) ? addUv[item2 - n] : ((lu != null) ? lu[item2] : Vector2.zero));
						if (!flag)
						{
							val = new Bounds(val2, Vector3.zero);
							flag = true;
						}
						else
						{
							((Bounds)(ref val)).Encapsulate(val2);
						}
					}
					array[i].Add(value);
				}
			}
			if (list.Count >= 12 && flag)
			{
				Vector3 val3 = ((Bounds)(ref val)).size;
				if (!(((Vector3)(ref val3)).magnitude < 0.08f))
				{
					int count2 = list.Count;
					List<int> list5 = null;
					if (hasFlesh && ln != null)
					{
						list5 = new List<int>();
						List<int> capEdges = BoundaryEdges(array, BuildCanon(list, count2));
						AppendFleshShell(list, list2, list3, array, list5, capEdges, capDirWorld);
					}
					Vector3 center = ((Bounds)(ref val)).center;
					Mesh val4 = new Mesh
					{
						name = "gorepiece"
					};
					if (list.Count > 65535)
					{
						val4.indexFormat = (IndexFormat)1;
					}
					Vector3[] array2 = (Vector3[])(object)new Vector3[list.Count];
					for (int j = 0; j < array2.Length; j++)
					{
						array2[j] = list[j] - center;
					}
					val4.vertices = array2;
					val4.normals = list2.ToArray();
					val4.uv = list3.ToArray();
					val4.subMeshCount = array.Length + ((list5 != null) ? 1 : 0);
					for (int k = 0; k < array.Length; k++)
					{
						val4.SetTriangles(array[k], k, false, 0);
					}
					if (list5 != null)
					{
						val4.SetTriangles(list5, array.Length, false, 0);
					}
					Bounds bounds = val;
					((Bounds)(ref bounds)).center = Vector3.zero;
					((Bounds)(ref bounds)).Expand(0.05f);
					val4.bounds = bounds;
					GameObject val5 = new GameObject("gorepiece");
					val5.transform.SetParent(pieceRoot.transform, false);
					val5.transform.position = center;
					val5.layer = LayerIndex.debris.intVal;
					MeshFilter val6 = val5.AddComponent<MeshFilter>();
					val6.sharedMesh = val4;
					MeshRenderer val7 = val5.AddComponent<MeshRenderer>();
					Material[] array3 = (Material[])(((Object)(object)parent.mr != (Object)null) ? ((Array)((Renderer)parent.mr).sharedMaterials) : ((Array)new Material[0]));
					Material[] array4 = (Material[])(object)new Material[val4.subMeshCount];
					for (int l = 0; l < array4.Length; l++)
					{
						array4[l] = ((l < array3.Length) ? array3[l] : ((array3.Length != 0) ? array3[^1] : null));
					}
					((Renderer)val7).sharedMaterials = array4;
					((Renderer)val7).shadowCastingMode = (ShadowCastingMode)1;
					Rigidbody val8 = val5.AddComponent<Rigidbody>();
					val8.drag = 0.05f;
					val8.angularDrag = 0.05f;
					val8.maxDepenetrationVelocity = 1.2f;
					val8.sleepThreshold = 0.05f;
					val8.solverIterations = 2;
					val8.solverVelocityIterations = 1;
					float num = Mathf.Max(((Bounds)(ref val)).size.x * ((Bounds)(ref val)).size.y * ((Bounds)(ref val)).size.z, 0.001f);
					val8.mass = Mathf.Clamp(num * 160f, 1.5f, 180f);
					GoreGib goreGib = val5.AddComponent<GoreGib>();
					goreGib.paletteIdx = parent.dripPalette;
					goreGib.splatBudget = 6;
					Vector3 val9;
					float num3;
					if (style == 3)
					{
						float num2 = Mathf.Sign(Vector3.Dot(center - cutPos, dir));
						val3 = dir * num2 + Vector3.up * 0.6f;
						val9 = ((Vector3)(ref val3)).normalized;
						num3 = 4f;
					}
					else
					{
						Vector3 val10 = center - cutPos;
						float magnitude = ((Vector3)(ref val10)).magnitude;
						val9 = ((magnitude > 0.01f) ? (val10 / magnitude) : Vector3.up);
						num3 = Mathf.Clamp(16f / (1f + magnitude), 5f, 14f);
					}
					Rigidbody val11 = (((Object)(object)parent.go != (Object)null) ? parent.go.GetComponent<Rigidbody>() : null);
					Vector3 val12 = (((Object)(object)val11 != (Object)null) ? Vector3.ClampMagnitude(val11.velocity, 25f) : Vector3.zero);
					val8.velocity = val12 + val9 * num3 + Vector3.up * 1.5f + RandomInSphere() * 0.8f;
					val8.angularVelocity = RandomInSphere() * (4f + (float)rng.NextDouble() * 6f);
					if (pieces.Count >= 32)
					{
						int num4 = ((pieces[0] == parent) ? 1 : 0);
						if (num4 < pieces.Count)
						{
							DestroyPiece(num4);
						}
					}
					float time = Time.time;
					Piece piece = new Piece
					{
						skinVerts = count2,
						skinSubs = array.Length,
						go = val5,
						tf = val5.transform,
						mesh = val4,
						mf = val6,
						mr = val7,
						palette = parent.palette,
						cuts = parent.cuts + 1,
						dieAt = time + 12f + (float)rng.NextDouble() * 3f,
						killY = center.y - 250f,
						dribbleUntil = time + 2.2f,
						nextDribble = time + 0.11f,
						born = time,
						dripPalette = parent.dripPalette,
						rb = val8
					};
					InheritPieceElement(piece, parent);
					pieces.Add(piece);
					BakeHullAsync(piece, val4);
					return true;
				}
			}
			return false;
		}

		private static void BakeHullAsync(Piece piece, Mesh m)
		{
			int meshId = ((Object)m).GetInstanceID();
			Task.Run(delegate
			{
				try
				{
					Physics.BakeMesh(meshId, true);
				}
				catch
				{
				}
				MainThread.Post(delegate
				{
					if (!((Object)(object)piece.go == (Object)null) && piece.mesh == m)
					{
						if ((Object)(object)piece.col == (Object)null)
						{
							BoxCollider component = piece.go.GetComponent<BoxCollider>();
							if ((Object)(object)component != (Object)null)
							{
								Object.Destroy((Object)(object)component);
							}
							piece.colSwapped = false;
							piece.col = piece.go.AddComponent<MeshCollider>();
							piece.col.convex = true;
						}
						piece.col.sharedMesh = m;
					}
				});
			});
		}

		private static int CountIndices(List<int>[] lists)
		{
			int num = 0;
			foreach (List<int> list in lists)
			{
				num += list.Count;
			}
			return num;
		}

		private static void DestroyPieceObject(Piece p)
		{
			int num = pieces.IndexOf(p);
			if (num >= 0)
			{
				DestroyPiece(num);
			}
		}

		private static Vector3 CorpseVelocity(Corpse c, Vector3 at)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody val = null;
			float num = float.MaxValue;
			foreach (Transform allBone in c.allBones)
			{
				if ((Object)(object)allBone == (Object)null)
				{
					continue;
				}
				Rigidbody component = ((Component)allBone).GetComponent<Rigidbody>();
				if (!((Object)(object)component == (Object)null) && !component.isKinematic)
				{
					Vector3 val2 = allBone.position - at;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						val = component;
					}
				}
			}
			if (!((Object)(object)val != (Object)null))
			{
				return Vector3.zero;
			}
			return Vector3.ClampMagnitude(val.velocity, 25f);
		}

		private static void DestroyPiece(int index)
		{
			Piece piece = pieces[index];
			pieces.RemoveAt(index);
			if ((Object)(object)piece.mesh != (Object)null)
			{
				Object.Destroy((Object)(object)piece.mesh);
			}
			if ((Object)(object)piece.go != (Object)null)
			{
				Object.Destroy((Object)(object)piece.go);
			}
		}

		private static void ForceRagdoll(CharacterBody body, Corpse c, GoreSystem.Blow blow)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0013: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val = ((((Vector3)(ref blow.force)).sqrMagnitude > 1f) ? Vector3.ClampMagnitude(blow.force * 0.02f, 9f) : (RandomInSphere() * 1.5f));
				val += Vector3.up * 2f;
				RagdollController component = ((Component)c.modelTf).GetComponent<RagdollController>();
				if ((Object)(object)component != (Object)null && component.bones != null && component.bones.Length != 0)
				{
					c.ragdollPending = true;
					ragdollQueue.Enqueue(new RagdollReq
					{
						c = c,
						push = val,
						rag = component
					});
					return;
				}
				if (c.allBones.Count < 3 && c.lateSmrs.Count == 0)
				{
					StatueTopple(body, c, val);
					return;
				}
				Animator[] componentsInChildren = ((Component)c.modelTf).GetComponentsInChildren<Animator>();
				foreach (Animator val2 in componentsInChildren)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						((Behaviour)val2).enabled = false;
					}
				}
				if ((Object)(object)body.modelLocator != (Object)null)
				{
					((Behaviour)body.modelLocator).enabled = false;
				}
				c.ragdollPending = true;
				ragdollQueue.Enqueue(new RagdollReq
				{
					c = c,
					push = val
				});
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreSkeleton force-ragdoll failed: {arg}");
			}
		}

		private static void DrainRagdollQueue()
		{
			//IL_00a0: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			if (ragdollQueue.Count == 0)
			{
				return;
			}
			int num = 0;
			Stopwatch stopwatch = Stopwatch.StartNew();
			while (ragdollQueue.Count > 0 && (num < 1 || (num < 2 && stopwatch.ElapsedMilliseconds < 6)))
			{
				RagdollReq ragdollReq = ragdollQueue.Dequeue();
				ragdollReq.c.ragdollPending = false;
				if ((Object)(object)ragdollReq.c.modelTf == (Object)null || !byModel.TryGetValue(ragdollReq.c.modelTf, out var value) || value != ragdollReq.c)
				{
					continue;
				}
				num++;
				try
				{
					if ((Object)(object)ragdollReq.rag != (Object)null)
					{
						ragdollReq.rag.BeginRagdoll(ragdollReq.push);
						continue;
					}
					Stopwatch stopwatch2 = (ModOptions.TestButtons.Value ? Stopwatch.StartNew() : null);
					if (!BuildProceduralRagdoll(ragdollReq.c, ragdollReq.push))
					{
						StatueTopple(null, ragdollReq.c, ragdollReq.push);
					}
					if (stopwatch2 != null && stopwatch2.ElapsedMilliseconds >= 25)
					{
						ManualLogSource log = ScorchedVoxelsPlugin.Log;
						Transform modelTf = ragdollReq.c.modelTf;
						log.LogInfo((object)$"[gore timing] ragdoll build {((modelTf != null) ? ((Object)modelTf).name : null)}: {stopwatch2.ElapsedMilliseconds}ms");
					}
				}
				catch (Exception e)
				{
					GoreSystem.WarnThrottled("GoreSkeleton ragdoll build", e);
				}
			}
		}

		private static bool BuildProceduralRagdoll(Corpse c, Vector3 push)
		{
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: 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_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c.modelTf != (Object)null && ((Object)c.modelTf).name.Contains("Worm"))
			{
				return true;
			}
			EnsureDeopt(c);
			foreach (Rend rend in c.rends)
			{
				PrepareRend(rend);
			}
			EnsureCore(c);
			Dictionary<Transform, float> totals = new Dictionary<Transform, float>();
			float num = 0f;
			foreach (Rend rend2 in c.rends)
			{
				if (rend2.dead || rend2.weights == null || rend2.boneAcc == null)
				{
					continue;
				}
				Transform[] bones = rend2.bones;
				float[] boneAcc = rend2.boneAcc;
				int num2 = Math.Min(boneAcc.Length, bones.Length);
				for (int i = 0; i < num2; i++)
				{
					if (!(boneAcc[i] <= 0f) && !((Object)(object)bones[i] == (Object)null))
					{
						totals.TryGetValue(bones[i], out var value);
						totals[bones[i]] = value + boneAcc[i];
					}
				}
			}
			foreach (KeyValuePair<Transform, float> item in totals)
			{
				num += item.Value;
			}
			if (num <= 0f || totals.Count < 3)
			{
				return false;
			}
			List<Transform> list = new List<Transform>();
			foreach (KeyValuePair<Transform, float> item2 in totals)
			{
				if (item2.Value >= num * 0.02f)
				{
					list.Add(item2.Key);
				}
			}
			list.Sort((Transform a, Transform b) => totals[b].CompareTo(totals[a]));
			if (list.Count > 12)
			{
				list.RemoveRange(12, list.Count - 12);
			}
			if (list.Count < 3)
			{
				return false;
			}
			HashSet<Transform> picked = new HashSet<Transform>(list);
			float num3 = Mathf.Clamp(40f + c.radius * c.radius * 25f, 60f, 900f);
			float num4 = Mathf.Clamp(c.radius * 0.1f, 0.06f, 0.45f);
			Dictionary<Transform, Rigidbody> dictionary = new Dictionary<Transform, Rigidbody>();
			foreach (Transform item3 in list)
			{
				float num5 = totals[item3] / num;
				Transform val = null;
				foreach (Transform item4 in list)
				{
					if (!((Object)(object)item4 != (Object)(object)item3) || !item4.IsChildOf(item3))
					{
						continue;
					}
					if (!((Object)(object)val == (Object)null))
					{
						Vector3 val2 = item4.position - item3.position;
						float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
						val2 = val.position - item3.position;
						if (!(sqrMagnitude < ((Vector3)(ref val2)).sqrMagnitude))
						{
							continue;
						}
					}
					val = item4;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = FindPickedAncestor(item3, picked);
				}
				Vector3 val3 = (((Object)(object)val != (Object)null) ? (val.position - item3.position) : Vector3.up);
				float num6 = Mathf.Max(((Vector3)(ref val3)).magnitude, num4 * 2.2f);
				Vector3 val4 = ((((Vector3)(ref val3)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref val3)).normalized : Vector3.up);
				float num7 = num4 * (0.7f + num5);
				Vector3 val5 = item3.position + val4 * num6;
				Vector3 position = item3.position;
				LayerIndex world = LayerIndex.world;
				if (Physics.CheckCapsule(position, val5, num7, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1))
				{
					Vector3 position2 = item3.position;
					float num8 = num7 * 0.4f;
					world = LayerIndex.world;
					if ((Physics.CheckCapsule(position2, val5, num8, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1) && BuriedForReal(item3.position, val5)) || HalfSunkVoxel(item3.position, val5, num7))
					{
						(c.planted ?? (c.planted = new List<PlantedBone>())).Add(new PlantedBone
						{
							bone = item3,
							share = num5,
							axisLocal = item3.InverseTransformDirection(val4),
							len = num6,
							capR = num7
						});
						continue;
					}
				}
				Rigidbody val6 = ((Component)item3).gameObject.GetComponent<Rigidbody>();
				if ((Object)(object)val6 == (Object)null)
				{
					val6 = ((Component)item3).gameObject.AddComponent<Rigidbody>();
				}
				val6.isKinematic = false;
				val6.mass = Mathf.Max(num3 * num5, 1f);
				val6.drag = 0.2f;
				val6.angularDrag = 0.6f;
				TameCorpseBody(val6);
				val6.interpolation = (RigidbodyInterpolation)1;
				dictionary[item3] = val6;
				CapsuleCollider obj = ((Component)item3).gameObject.AddComponent<CapsuleCollider>();
				Vector3 val7 = item3.InverseTransformDirection(val4);
				int direction = ((!(Mathf.Abs(val7.x) >= Mathf.Abs(val7.y)) || !(Mathf.Abs(val7.x) >= Mathf.Abs(val7.z))) ? ((Mathf.Abs(val7.y) >= Mathf.Abs(val7.z)) ? 1 : 2) : 0);
				obj.direction = direction;
				float num9 = ((item3.lossyScale.x > 0.0001f) ? (1f / item3.lossyScale.x) : 1f);
				obj.radius = num7 * num9;
				obj.height = num6 * num9;
				obj.center = val7 * (num6 * 0.5f * num9);
				((Component)item3).gameObject.layer = LayerIndex.ragdoll.intVal;
			}
			if (c.planted != null)
			{
				c.pickedBones = list;
				c.ragdollMass = num3;
			}
			if (dictionary.Count == 0)
			{
				return true;
			}
			foreach (Transform item5 in list)
			{
				if (dictionary.TryGetValue(item5, out var _))
				{
					Transform val8 = FindPickedAncestor(item5, picked);
					if (!((Object)(object)val8 == (Object)null))
					{
						dictionary.TryGetValue(val8, out var value3);
						AddCorpseJoint(((Component)item5).gameObject, value3);
					}
				}
			}
			foreach (KeyValuePair<Transform, Rigidbody> item6 in dictionary)
			{
				item6.Value.velocity = push * (0.8f + (float)rng.NextDouble() * 0.4f);
			}
			return true;
		}

		private static Transform FindPickedAncestor(Transform bone, HashSet<Transform> picked)
		{
			Transform parent = bone.parent;
			while ((Object)(object)parent != (Object)null)
			{
				if (picked.Contains(parent))
				{
					return parent;
				}
				parent = parent.parent;
			}
			return null;
		}

		private static CharacterJoint AddCorpseJoint(GameObject go, Rigidbody connected)
		{
			//IL_0015: 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)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			CharacterJoint obj = go.AddComponent<CharacterJoint>();
			((Joint)obj).connectedBody = connected;
			obj.enableProjection = true;
			SoftJointLimit val = obj.lowTwistLimit;
			((SoftJointLimit)(ref val)).limit = -35f;
			obj.lowTwistLimit = val;
			val = obj.highTwistLimit;
			((SoftJointLimit)(ref val)).limit = 35f;
			obj.highTwistLimit = val;
			SoftJointLimit val2 = obj.swing1Limit;
			((SoftJointLimit)(ref val2)).limit = 45f;
			obj.swing1Limit = val2;
			val2 = obj.swing2Limit;
			((SoftJointLimit)(ref val2)).limit = 25f;
			obj.swing2Limit = val2;
			return obj;
		}

		private static bool BuriedForReal(Vector3 a, Vector3 b)
		{
			//IL_0000: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return VoxelTerrainManager.SolidAtWorld(a, uncovered: true) || VoxelTerrainManager.SolidAtWorld((a + b) * 0.5f, uncovered: true) || VoxelTerrainManager.SolidAtWorld(b, uncovered: true);
			}
			catch
			{
				return true;
			}
		}

		private static bool HalfSunkVoxel(Vector3 a, Vector3 b, float capR)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0032: 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_0040: 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)
			Vector3 val = Vector3.down * (capR * 0.5f);
			try
			{
				return VoxelTerrainManager.SolidAtWorld(a + val, uncovered: false) || VoxelTerrainManager.SolidAtWorld((a + b) * 0.5f + val, uncovered: false) || VoxelTerrainManager.SolidAtWorld(b + val, uncovered: false);
			}
			catch
			{
				return false;
			}
		}

		private static void ScheduleUnearthProbe(Corpse c)
		{
			if ((c.planted != null && c.planted.Count != 0) || c.statueWedged)
			{
				c.unearthAt = Time.time + 0.6f;
				c.unearthTries = 2;
			}
		}

		private static void TryUnearth(Corpse c)
		{
			//IL_001f: 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)
			//IL_0038: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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)
			if ((Object)(object)c.modelTf == (Object)null)
			{
				return;
			}
			if (c.statueWedged)
			{
				WakeCorpse(c);
				StatueTopple(null, c, Vector3.up * 0.4f + RandomInSphere() * 0.3f);
				Rigidbody component = ((Component)c.modelTf).GetComponent<Rigidbody>();
				if ((Object)(object)component != (Object)null)
				{
					c.statueWedged = false;
					c.unearthTries = 0;
					if (c.rbsReady)
					{
						c.rbs.Add(component);
					}
				}
				return;
			}
			if (c.planted == null || c.planted.Count == 0)
			{
				c.unearthTries = 0;
				return;
			}
			bool flag = false;
			for (int num = c.planted.Count - 1; num >= 0; num--)
			{
				PlantedBone pb = c.planted[num];
				if ((Object)(object)pb.bone == (Object)null)
				{
					c.planted.RemoveAt(num);
				}
				else
				{
					Vector3 val = pb.bone.TransformDirection(pb.axisLocal);
					val = ((((Vector3)(ref val)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref val)).normalized : Vector3.up);
					Vector3 position = pb.bone.position;
					Vector3 val2 = pb.bone.position + val * pb.len;
					float num2 = pb.capR * 0.4f;
					LayerIndex world = LayerIndex.world;
					if (!Physics.CheckCapsule(position, val2, num2, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1) || !BuriedForReal(pb.bone.position, pb.bone.position + val * pb.len))
					{
						if (!flag)
						{
							WakeCorpse(c);
						}
						PromoteBone(c, pb);
						c.planted.RemoveAt(num);
						flag = true;
					}
				}
			}
			if (flag)
			{
				RefreshRagdollJoints(c);
			}
			if (c.planted.Count == 0)
			{
				c.unearthTries = 0;
			}
		}

		private static void PromoteBone(Corpse c, PlantedBone pb)
		{
			//IL_007b: 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_0081: 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_00b1: 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_0099: 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_00d9: 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_0122: 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)
			Transform bone = pb.bone;
			Rigidbody val = ((Component)bone).gameObject.GetComponent<Rigidbody>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)bone).gameObject.AddComponent<Rigidbody>();
			}
			val.isKinematic = false;
			val.mass = Mathf.Max(c.ragdollMass * pb.share, 1f);
			val.drag = 0.2f;
			val.angularDrag = 0.6f;
			TameCorpseBody(val);
			val.interpolation = (RigidbodyInterpolation)1;
			CapsuleCollider obj = ((Component)bone).gameObject.AddComponent<CapsuleCollider>();
			Vector3 axisLocal = pb.axisLocal;
			int direction = ((!(Mathf.Abs(axisLocal.x) >= Mathf.Abs(axisLocal.y)) || !(Mathf.Abs(axisLocal.x) >= Mathf.Abs(axisLocal.z))) ? ((Mathf.Abs(axisLocal.y) >= Mathf.Abs(axisLocal.z)) ? 1 : 2) : 0);
			obj.direction = direction;
			float num = ((bone.lossyScale.x > 0.0001f) ? (1f / bone.lossyScale.x) : 1f);
			obj.radius = pb.capR * num;
			obj.height = pb.len * num;
			obj.center = axisLocal * (pb.len * 0.5f * num);
			((Component)bone).gameObject.layer = LayerIndex.ragdoll.intVal;
			if (c.rbsReady)
			{
				c.rbs.Add(val);
			}
		}

		private static void RefreshRagdollJoints(Corpse c)
		{
			if (c.pickedBones == null)
			{
				return;
			}
			HashSet<Transform> picked = new HashSet<Transform>(c.pickedBones);
			foreach (Transform pickedBone in c.pickedBones)
			{
				if ((Object)(object)pickedBone == (Object)null || (Object)(object)((Component)pickedBone).GetComponent<Rigidbody>() == (Object)null)
				{
					continue;
				}
				Transform val = FindPickedAncestor(pickedBone, picked);
				if (!((Object)(object)val == (Object)null))
				{
					Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
					CharacterJoint component2 = ((Component)pickedBone).GetComponent<CharacterJoint>();
					if ((Object)(object)component2 == (Object)null)
					{
						AddCorpseJoint(((Component)pickedBone).gameObject, component);
					}
					else if ((Object)(object)((Joint)component2).connectedBody == (Object)null && (Object)(object)component != (Object)null)
					{
						((Joint)component2).connectedBody = component;
					}
				}
			}
		}

		private static void TameCorpseBody(Rigidbody rb)
		{
			rb.maxDepenetrationVelocity = 0.3f;
			rb.sleepThreshold = 0.05f;
			rb.solverIterations = 2;
			rb.solverVelocityIterations = 1;
		}

		private static void StatueTopple(CharacterBody body, Corpse c, Vector3 push)
		{
			//IL_0055: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00b1: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: 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)
			Animator[] componentsInChildren = ((Component)c.modelTf).GetComponentsInChildren<Animator>();
			foreach (Animator val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					((Behaviour)val).enabled = false;
				}
			}
			GameObject gameObject = ((Component)c.modelTf).gameObject;
			if ((Object)(object)gameObject.GetComponent<Rigidbody>() != (Object)null)
			{
				return;
			}
			Vector3 val2 = Vector3.Min(c.boundsSize * 0.35f, Vector3.one * 6f) * 0.4f;
			Vector3 center = c.center;
			Quaternion rotation = c.modelTf.rotation;
			LayerIndex world = LayerIndex.world;
			if (Physics.CheckBox(center, val2, rotation, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1) && BuriedForReal(c.center, c.center))
			{
				c.statueWedged = true;
				return;
			}
			c.statueWedged = false;
			if ((Object)(object)body != (Object)null && (Object)(object)body.modelLocator != (Object)null)
			{
				((Behaviour)body.modelLocator).enabled = false;
			}
			BoxCollider obj = gameObject.AddComponent<BoxCollider>();
			Vector3 val3 = c.modelTf.InverseTransformVector(c.boundsSize);
			((Vector3)(ref val3))..ctor(Mathf.Abs(val3.x), Mathf.Abs(val3.y), Mathf.Abs(val3.z));
			obj.size = Vector3.Max(Vector3.Min(val3 * 0.7f, Vector3.one * 12f), Vector3.one * 0.25f);
			obj.center = c.modelTf.InverseTransformPoint(c.center);
			gameObject.layer = LayerIndex.debris.intVal;
			Rigidbody obj2 = gameObject.AddComponent<Rigidbody>();
			obj2.mass = Mathf.Clamp(c.radius * c.radius * 60f, 80f, 1500f);
			TameCorpseBody(obj2);
			obj2.velocity = push * 0.6f;
			Vector3 val4 = Vector3.Cross(Vector3.up, (((Vector3)(ref push)).sqrMagnitude > 0.01f) ? ((Vector3)(ref push)).normalized : RandomInSphere());
			obj2.angularVelocity = ((((Vector3)(ref val4)).sqrMagnitude > 0.01f) ? ((Vector3)(ref val4)).normalized : Vector3.right) * (2.2f + (float)rng.NextDouble() * 1.5f);
		}

		private static void EvaluateLod(Corpse c, float now, Vector3 eye, bool hasEye)
		{
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: 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_0266: Unknown result type (might be due to invalid IL or missing references)
			if (!c.adopted || now < c.nextLodAt)
			{
				return;
			}
			c.nextLodAt = now + 0.45f;
			if (!c.rbsReady)
			{
				if (c.ragdollPending || now - c.bornAt < 1f)
				{
					return;
				}
				c.rbsReady = true;
				((Component)c.modelTf).GetComponentsInChildren<Rigidbody>(true, rbScratch);
				c.rbs.AddRange(rbScratch);
				rbScratch.Clear();
				foreach (Rigidbody rb in c.rbs)
				{
					if ((Object)(object)rb != (Object)null && !rb.isKinematic)
					{
						TameCorpseBody(rb);
					}
				}
				c.fallFloor = (((Object)(object)c.refBone != (Object)null) ? c.refBone.position.y : c.modelTf.position.y) - 250f;
			}
			if (c.rbs.Count == 0)
			{
				if (!c.frozen)
				{
					FreezeCorpse(c);
				}
			}
			else
			{
				if (c.frozen)
				{
					return;
				}
				Vector3 val = (((Object)(object)c.refBone != (Object)null) ? c.refBone.position : c.modelTf.position);
				if (val.y < c.fallFloor)
				{
					c.expireAt = float.NegativeInfinity;
					return;
				}
				float num = 0f;
				Vector3 val2;
				foreach (Rigidbody rb2 in c.rbs)
				{
					if ((Object)(object)rb2 == (Object)null || rb2.isKinematic || rb2.IsSleeping())
					{
						continue;
					}
					if (rb2.position.y < c.fallFloor)
					{
						rb2.collisionDetectionMode = (CollisionDetectionMode)0;
						rb2.isKinematic = true;
						rb2.detectCollisions = false;
						((Component)rb2).transform.position = val;
						continue;
					}
					val2 = rb2.velocity;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude > num)
					{
						num = sqrMagnitude;
					}
				}
				if (num > 0.16000001f)
				{
					c.restSince = -1f;
					return;
				}
				if (c.restSince < 0f)
				{
					c.restSince = now;
					return;
				}
				Vector3 val3 = (((Object)(object)c.refBone != (Object)null) ? c.refBone.position : c.modelTf.position);
				int num2;
				if (hasEye)
				{
					val2 = val3 - eye;
					num2 = ((((Vector3)(ref val2)).sqrMagnitude < 2025f) ? 1 : 0);
				}
				else
				{
					num2 = 1;
				}
				bool flag = (byte)num2 != 0;
				if (now - c.restSince >= (flag ? 1.25f : 0.75f))
				{
					FreezeCorpse(c);
				}
			}
		}

		private static void FreezeCorpse(Corpse c)
		{
			c.frozen = true;
			for (int num = c.rbs.Count - 1; num >= 0; num--)
			{
				Rigidbody val = c.rbs[num];
				if ((Object)(object)val == (Object)null || val.isKinematic)
				{
					c.rbs.RemoveAt(num);
				}
				else
				{
					val.collisionDetectionMode = (CollisionDetectionMode)0;
					val.isKinematic = true;
				}
			}
			CheapenFrozenSkinning(c);
		}

		private static void WakeCorpse(Corpse c)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!c.frozen)
			{
				return;
			}
			c.frozen = false;
			c.restSince = -1f;
			RestoreFrozenSkinning(c);
			foreach (Rigidbody rb in c.rbs)
			{
				if (!((Object)(object)rb == (Object)null))
				{
					rb.isKinematic = false;
					rb.velocity = Vector3.zero;
					rb.angularVelocity = Vector3.zero;
				}
			}
		}

		private static void CheapenFrozenSkinning(Corpse c)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_007b: 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_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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)c.modelTf == (Object)null)
			{
				return;
			}
			((Component)c.modelTf).GetComponentsInChildren<SkinnedMeshRenderer>(false, lodSmrScratch);
			foreach (SkinnedMeshRenderer item in lodSmrScratch)
			{
				if ((Object)(object)item == (Object)null || !((Renderer)item).enabled || (Object)(object)item.sharedMesh == (Object)null)
				{
					continue;
				}
				try
				{
					Mesh val = new Mesh
					{
						name = "frozensnap"
					};
					item.BakeMesh(val, false);
					Bounds val2 = val.bounds;
					Vector3 size = ((Bounds)(ref val2)).size;
					float magnitude = ((Vector3)(ref size)).magnitude;
					val2 = ((Renderer)item).localBounds;
					size = ((Bounds)(ref val2)).size;
					float magnitude2 = ((Vector3)(ref size)).magnitude;
					GameObject val3 = new GameObject("frozensnap");
					val3.transform.SetParent(((Component)item).transform, false);
					val3.layer = ((Component)item).gameObject.layer;
					if (magnitude > 0.0001f && magnitude2 > 0.0001f)
					{
						float num = magnitude2 / magnitude;
						if (num < 0.9f || num > 1.1f)
						{
							val3.transform.localScale = Vector3.one * num;
						}
					}
					val3.AddComponent<MeshFilter>().sharedMesh = val;
					MeshRenderer obj = val3.AddComponent<MeshRenderer>();
					((Renderer)obj).sharedMaterials = ((Renderer)item).sharedMaterials;
					((Renderer)obj).shadowCastingMode = ((Renderer)item).shadowCastingMode;
					((Renderer)item).GetPropertyBlock(mpbScratch);
					((Renderer)obj).SetPropertyBlock(mpbScratch);
					((Renderer)item).enabled = false;
					c.frozenSnaps.Add(new FrozenSnap
					{
						go = val3,
						mesh = val,
						smr = item
					});
				}
				catch (Exception e)
				{
					GoreSystem.WarnThrottled("GoreSkeleton frozen snap", e);
				}
			}
			lodSmrScratch.Clear();
			c.tintRendsAtCuts = -1;
		}

		private static void RestoreFrozenSkinning(Corpse c)
		{
			foreach (FrozenSnap frozenSnap in c.frozenSnaps)
			{
				if ((Object)(object)frozenSnap.smr != (Object)null)
				{
					((Renderer)frozenSnap.smr).enabled = true;
				}
				if ((Object)(object)frozenSnap.go != (Object)null)
				{
					Object.Destroy((Object)(object)frozenSnap.go);
				}
				if ((Object)(object)frozenSnap.mesh != (Object)null)
				{
					Object.Destroy((Object)(object)frozenSnap.mesh);
				}
			}
			c.frozenSnaps.Clear();
			c.tintRendsAtCuts = -1;
		}

		private static void LockAnimators(Corpse c)
		{
			try
			{
				c.anims = ((Component)c.modelTf).GetComponentsInChildren<Animator>(true);
				Animator[] anims = c.anims;
				foreach (Animator val in anims)
				{
					if ((Object)(object)val != (Object)null)
					{
						((Behaviour)val).enabled = false;
					}
				}
				c.animLockUntil = Time.time + 3f;
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreSkeleton animator lock failed: {arg}");
			}
		}

		private static void CacheSkinSlots(Corpse c, CharacterModel cm)
		{
			//IL_001e: 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)
			//IL_0025: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cm != (Object)null && cm.baseRendererInfos != null)
			{
				RendererInfo[] baseRendererInfos = cm.baseRendererInfos;
				foreach (RendererInfo info in baseRendererInfos)
				{
					AddSkinSlot(c, info);
				}
			}
			ItemDisplay[] componentsInChildren = ((Component)c.modelTf).GetComponentsInChildren<ItemDisplay>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				RendererInfo[] rendererInfos = componentsInChildren[i].rendererInfos;
				if (rendererInfos != null)
				{
					RendererInfo[] baseRendererInfos = rendererInfos;
					foreach (RendererInfo info2 in baseRendererInfos)
					{
						AddSkinSlot(c, info2);
					}
				}
			}
		}

		private static void AddSkinSlot(Corpse c, RendererInfo info)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)info.renderer == (Object)null)
			{
				return;
			}
			Material val = info.defaultMaterial;
			info.renderer.GetSharedMaterials(restoreScratch);
			if (restoreScratch.Count > 0)
			{
				Material val2 = restoreScratch[0];
				if ((Object)(object)val2 != (Object)null && val2 != val && !((Object)val2).name.EndsWith("(Instance)"))
				{
					val = val2;
				}
			}
			c.skinSlots.Add(new SkinSlot
			{
				r = info.renderer,
				baseMats = (Material[])((!((Object)(object)val != (Object)null)) ? ((Array)Array.Empty<Material>()) : ((Array)new Material[1] { val }))
			});
		}

		private static void RestoreSkinMaterials(Corpse c)
		{
			if (c.skinSlots.Count == 0)
			{
				StripOverlaySlots(c.modelTf);
				return;
			}
			foreach (SkinSlot skinSlot in c.skinSlots)
			{
				if ((Object)(object)skinSlot.r == (Object)null)
				{
					continue;
				}
				skinSlot.r.GetSharedMaterials(restoreScratch);
				bool flag = restoreScratch.Count != skinSlot.baseMats.Length;
				if (!flag)
				{
					for (int i = 0; i < skinSlot.baseMats.Length; i++)
					{
						if (restoreScratch[i] != skinSlot.baseMats[i])
						{
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					skinSlot.r.sharedMaterials = skinSlot.baseMats;
				}
			}
		}

		private static void StripOverlaySlots(Transform modelTf)
		{
			Renderer[] componentsInChildren = ((Component)modelTf).GetComponentsInChildren<Renderer>(true);
			MeshFilter val4 = default(MeshFilter);
			foreach (Renderer val in componentsInChildren)
			{
				SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((val is SkinnedMeshRenderer) ? val : null);
				Mesh val3 = ((val2 != null) ? val2.sharedMesh : (((Component)val).TryGetComponent<MeshFilter>(ref val4) ? val4.sharedMesh : null));
				if (!((Object)(object)val3 == (Object)null))
				{
					Material[] sharedMaterials = val.sharedMaterials;
					if (sharedMaterials.Length > val3.subMeshCount)
					{
						Material[] array = (Material[])(object)new Material[val3.subMeshCount];
						Array.Copy(sharedMaterials, array, val3.subMeshCount);
						val.sharedMaterials = array;
					}
				}
			}
		}

		private static void DeregisterHurtBoxes(Transform modelTf)
		{
			HurtBoxGroup component = ((Component)modelTf).GetComponent<HurtBoxGroup>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			HurtBox[] componentsInChildren = ((Component)modelTf).GetComponentsInChildren<HurtBox>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Collider component2 = ((Component)componentsInChildren[i]).GetComponent<Collider>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.enabled = false;
				}
				((Behaviour)componentsInChildren[i]).enabled = false;
			}
		}

		private static void CacheMeshEmitters(Corpse c)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			ParticleSystem[] componentsInChildren = ((Component)c.modelTf).GetComponentsInChildren<ParticleSystem>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				ShapeModule shape = componentsInChildren[i].shape;
				ParticleSystemShapeType shapeType = ((ShapeModule)(ref shape)).shapeType;
				if ((int)shapeType == 6 || (int)shapeType == 13 || (int)shapeType == 14)
				{
					c.meshEmitters.Add(componentsInChildren[i]);
				}
			}
		}

		private static void StopStarvedEmitters(Corpse c)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			for (int num = c.meshEmitters.Count - 1; num >= 0; num--)
			{
				ParticleSystem val = c.meshEmitters[num];
				if ((Object)(object)val == (Object)null)
				{
					c.meshEmitters.RemoveAt(num);
				}
				else
				{
					ShapeModule shape = val.shape;
					Mesh val2 = null;
					ParticleSystemShapeType shapeType = ((ShapeModule)(ref shape)).shapeType;
					if ((int)shapeType != 6)
					{
						if ((int)shapeType != 13)
						{
							if ((int)shapeType == 14)
							{
								SkinnedMeshRenderer skinnedMeshRenderer = ((ShapeModule)(ref shape)).skinnedMeshRenderer;
								val2 = (((Object)(object)skinnedMeshRenderer != (Object)null) ? skinnedMeshRenderer.sharedMesh : null);
							}
						}
						else
						{
							MeshRenderer meshRenderer = ((ShapeModule)(ref shape)).meshRenderer;
							MeshFilter val3 = (((Object)(object)meshRenderer != (Object)null) ? ((Component)meshRenderer).GetComponent<MeshFilter>() : null);
							val2 = (((Object)(object)val3 != (Object)null) ? val3.sharedMesh : null);
						}
					}
					else
					{
						val2 = ((ShapeModule)(ref shape)).mesh;
					}
					long num2 = 0L;
					if ((Object)(object)val2 != (Object)null)
					{
						for (int i = 0; i < val2.subMeshCount; i++)
						{
							if (num2 != 0L)
							{
								break;
							}
							num2 += val2.GetIndexCount(i);
						}
					}
					if (num2 <= 0)
					{
						val.Stop(false, (ParticleSystemStopBehavior)1);
						c.meshEmitters.RemoveAt(num);
					}
				}
			}
		}

		private static void SnatchModel(CharacterBody body)
		{
			try
			{
				if ((Object)(object)body.modelLocator != (Object)null)
				{
					body.modelLocator.modelTransform = null;
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreSkeleton model snatch failed: {arg}");
			}
		}

		private static void AdoptCorpse(CharacterBody body, Corpse c)
		{
			try
			{
				if (!body.isPlayerControlled)
				{
					c.modelTf.SetParent((Transform)null, true);
					CharacterModel component = ((Component)c.modelTf).GetComponent<CharacterModel>();
					if ((Object)(object)component != (Object)null)
					{
						((Behaviour)component).enabled = false;
					}
					CacheSkinSlots(c, component);
					RestoreSkinMaterials(c);
					DeregisterHurtBoxes(c.modelTf);
					WormBodyPositionsDriver component2 = ((Component)body).GetComponent<WormBodyPositionsDriver>();
					if ((Object)(object)component2 != (Object)null)
					{
						((Behaviour)component2).enabled = false;
					}
					WormBodyPositions2 component3 = ((Component)body).GetComponent<WormBodyPositions2>();
					if ((Object)(object)component3 != (Object)null)
					{
						((Behaviour)component3).enabled = false;
					}
					CacheMeshEmitters(c);
					StopStarvedEmitters(c);
					c.adopted = true;
					HealthComponent healthComponent = body.healthComponent;
					if ((Object)(object)healthComponent != (Object)null && healthComponent.destroyModelOnDeath)
					{
						SnatchModel(body);
					}
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreSkeleton corpse adoption failed: {arg}");
			}
		}

		private static void SubmitJob(IGoreJob job)
		{
			if (goreWorker == null)
			{
				goreWorker = new Thread(WorkerLoop)
				{
					IsBackground = true,
					Name = "ScorchedVoxels gore",
					Priority = ThreadPriority.BelowNormal
				};
				goreWorker.Start();
			}
			workerIn.Enqueue(job);
			workerWake.Set();
		}

		private static void WorkerLoop()
		{
			while (true)
			{
				workerWake.WaitOne();
				IGoreJob result;
				while (workerIn.TryDequeue(out result))
				{
					long t = GoreProf.Begin();
					try
					{
						result.Compute();
					}
					catch (Exception error)
					{
						((GoreJobBase)result).error = error;
					}
					GoreProf.End((result is CutJob) ? 45 : 46, t);
					workerOut.Enqueue(result);
				}
			}
		}

		private static void DrainWorkerResults()
		{
			if (workerOut.IsEmpty)
			{
				return;
			}
			long timestamp = Stopwatch.GetTimestamp();
			int num = 0;
			IGoreJob result;
			while (workerOut.TryDequeue(out result))
			{
				long t = GoreProf.Begin();
				try
				{
					result.Apply();
				}
				catch (Exception e)
				{
					GoreSystem.WarnThrottled("GoreSkeleton apply", e);
				}
				GoreProf.End((result is CutJob) ? 6 : 7, t);
				num++;
				if (num >= 1 && PhaseMs(Stopwatch.GetTimestamp() - timestamp) >= 8.0)
				{
					break;
				}
			}
		}
	}
	internal static class GoreSystem
	{
		internal struct Blow
		{
			public byte kind;

			public byte element;

			public bool oiled;

			public Vector3 pos;

			public Vector3 force;

			public float radius;

			public Vector3 slabPos;

			public Quaternion slabRot;

			public Vector3 slabHalf;

			public uint overkill;

			private const int ElementShift = 11;

			private const uint OverkillMask = 2047u;

			private const uint OiledBit = 32768u;

			public uint PackAux()
			{
				return (overkill & 0x7FF) | (uint)(element << 11) | (uint)(oiled ? 32768 : 0);
			}

			public void UnpackAux(uint aux)
			{
				overkill = aux & 0x7FF;
				element = (byte)((aux >> 11) & 0xF);
				oiled = (aux & 0x8000) != 0;
			}
		}

		private struct Palette
		{
			public readonly Color color;

			public readonly bool matte;

			public readonly Color bone;

			public readonly float boneGloss;

			public readonly Color emission;

			public Palette(float r, float g, float b, bool matte = false, float boneR = 0.78f, float boneG = 0.74f, float boneB = 0.62f, float boneGloss = 0.35f, float emR = 0f, float emG = 0f, float emB = 0f)
			{
				//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_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: 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)
				color = new Color(r, g, b);
				this.matte = matte;
				bone = new Color(boneR, boneG, boneB);
				this.boneGloss = boneGloss;
				emission = new Color(emR, emG, emB);
			}
		}

		private struct BloodEntry
		{
			public readonly string fragment;

			public readonly int palette;

			public BloodEntry(string fragment, int palette)
			{
				this.fragment = fragment;
				this.palette = palette;
			}
		}

		private struct RecentBlast
		{
			public Vector3 pos;

			public float radius;

			public float time;
		}

		private struct RecentSlab
		{
			public GameObject attacker;

			public Vector3 pos;

			public Quaternion rot;

			public Vector3 half;

			public float time;
		}

		private struct StainReq
		{
			public Vector3 pos;

			public float radius;

			public int palette;
		}

		private class StainJob
		{
			public Vector3 pos;

			public float radius;

			public int palette;

			public readonly List<(VoxelVolume vol, long key, Vector3 org)> chunks = new List<(VoxelVolume, long, Vector3)>(8);

			public int next;
		}

		private struct RecentStain
		{
			public Vector3 pos;

			public float radius;

			public int palette;

			public float until;
		}

		private static class Splats
		{
			private class Bucket
			{
				public GameObject go;

				public Mesh mesh;

				public readonly List<Vector3> v = new List<Vector3>(17600);

				public readonly List<Vector3> n = new List<Vector3>(17600);

				public readonly List<int> tri = new List<int>(26400);

				public readonly List<Vector4> meta = new List<Vector4>(4400);

				public int quads;

				public bool dirty;

				public float nextUploadAt;

				public Vector3 bMin;

				public Vector3 bMax;

				public bool hasBounds;
			}

			private class Grow
			{
				public Bucket b;

				public int quad;

				public Vector3 pos;

				public Vector3 u1;

				public Vector3 u2;

				public float born;

				public float dur;

				public float s0;

				public float s1;
			}

			private const int MaxQuadsPerBucket = 4400;

			private static readonly Dictionary<int, Bucket> buckets = new Dictionary<int, Bucket>();

			private static readonly Dictionary<int, Material> materials = new Dictionary<int, Material>();

			private static GameObject root;

			private static bool shaderWarned;

			private static readonly Bounds HugeBounds = new Bounds(Vector3.zero, Vector3.one * 4000f);

			private static readonly List<Grow> grows = new List<Grow>();

			private static void GrowBounds(Bucket b, Vector3 p)
			{
				//IL_0020: 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_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_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: 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_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				if (!b.hasBounds)
				{
					b.bMin = p;
					b.bMax = p;
					b.hasBounds = true;
				}
				else
				{
					b.bMin = Vector3.Min(b.bMin, p);
					b.bMax = Vector3.Max(b.bMax, p);
				}
			}

			public static void Reset()
			{
				foreach (Bucket value in buckets.Values)
				{
					if ((Object)(object)value.mesh != (Object)null)
					{
						Object.Destroy((Object)(object)value.mesh);
					}
				}
				buckets.Clear();
				grows.Clear();
				if ((Object)(object)root != (Object)null)
				{
					Object.Destroy((Object)(object)root);
				}
				root = null;
			}

			public static void Tick()
			{
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				float time = Time.time;
				GrowTick(time);
				foreach (Bucket value in buckets.Values)
				{
					if (value.dirty && !((Object)(object)value.mesh == (Object)null) && !(time < value.nextUploadAt))
					{
						value.nextUploadAt = time + UploadThrottle(value.v.Count);
						value.mesh.Clear();
						value.mesh.SetVertices(value.v);
						value.mesh.SetNormals(value.n);
						value.mesh.SetTriangles(value.tri, 0, false, 0);
						value.mesh.bounds = HugeBounds;
						value.dirty = false;
					}
				}
			}

			public static void Add(Vector3 pos, Vector3 normal, float size, int palette)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: 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_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: 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_0169: 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_0172: 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_01f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0207: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				Bucket bucket = GetBucket(palette);
				if (bucket != null)
				{
					if (bucket.quads >= 4400)
					{
						Compact(bucket);
					}
					Vector3 val = ((Mathf.Abs(normal.y) < 0.8f) ? Vector3.up : Vector3.forward);
					Vector3 val2 = Vector3.Normalize(Vector3.Cross(normal, val));
					Vector3 val3 = Vector3.Cross(normal, val2);
					float num = (float)(rng.NextDouble() * Math.PI * 2.0);
					float num2 = Mathf.Cos(num);
					float num3 = Mathf.Sin(num);
					Vector3 val4 = (val2 * num2 + val3 * num3) * (size * 0.5f);
					Vector3 val5 = (val3 * num2 - val2 * num3) * (size * 0.5f * (0.7f + (float)rng.NextDouble() * 0.6f));
					Vector3 val6 = pos + normal * (0.018f + (float)rng.NextDouble() * 0.03f);
					int count = bucket.v.Count;
					bucket.v.Add(val6 - val4 - val5);
					bucket.v.Add(val6 + val4 - val5);
					bucket.v.Add(val6 + val4 + val5);
					bucket.v.Add(val6 - val4 + val5);
					for (int i = 0; i < 4; i++)
					{
						bucket.n.Add(normal);
					}
					bucket.tri.Add(count);
					bucket.tri.Add(count + 1);
					bucket.tri.Add(count + 2);
					bucket.tri.Add(count);
					bucket.tri.Add(count + 2);
					bucket.tri.Add(count + 3);
					bucket.meta.Add(new Vector4(pos.x, pos.y, pos.z, size));
					GrowBounds(bucket, pos);
					bucket.quads++;
					bucket.dirty = true;
				}
			}

			public static void Burst(Vector3 origin, Vector3 dir, int count, float len, float sizeMin, float sizeMax, int palette, float coneDeg)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				Drops.EmitBurst(origin, dir, count, len, sizeMin, sizeMax, palette, coneDeg);
			}

			public static void AddGrowing(Vector3 pos, Vector3 normal, float s0, float s1, float dur, int palette)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: 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_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: 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_009b: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: 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_0151: 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_01ce: 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_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				Bucket bucket = GetBucket(palette);
				if (bucket != null)
				{
					if (bucket.quads >= 4400)
					{
						Compact(bucket);
					}
					Vector3 val = ((Mathf.Abs(normal.y) < 0.8f) ? Vector3.up : Vector3.forward);
					Vector3 val2 = Vector3.Normalize(Vector3.Cross(normal, val));
					Vector3 val3 = Vector3.Cross(normal, val2);
					float num = (float)(rng.NextDouble() * Math.PI * 2.0);
					float num2 = Mathf.Cos(num);
					float num3 = Mathf.Sin(num);
					Grow grow = new Grow
					{
						b = bucket,
						quad = bucket.quads,
						pos = pos + normal * (0.02f + (float)rng.NextDouble() * 0.02f),
						u1 = val2 * num2 + val3 * num3,
						u2 = (val3 * num2 - val2 * num3) * (0.75f + (float)rng.NextDouble() * 0.4f),
						born = Time.time,
						dur = dur,
						s0 = s0,
						s1 = s1
					};
					int count = bucket.v.Count;
					for (int i = 0; i < 4; i++)
					{
						bucket.v.Add(grow.pos);
						bucket.n.Add(normal);
					}
					bucket.tri.Add(count);
					bucket.tri.Add(count + 1);
					bucket.tri.Add(count + 2);
					bucket.tri.Add(count);
					bucket.tri.Add(count + 2);
					bucket.tri.Add(count + 3);
					bucket.meta.Add(new Vector4(pos.x, pos.y, pos.z, s1));
					GrowBounds(bucket, pos);
					bucket.quads++;
					bucket.dirty = true;
					grows.Add(grow);
					WriteGrow(grow, s0);
				}
			}

			private static void WriteGrow(Grow g, float size)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_001d: 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)
				//IL_003c: 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_0047: 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_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				int num = g.quad * 4;
				Vector3 val = g.u1 * (size * 0.5f);
				Vector3 val2 = g.u2 * (size * 0.5f);
				g.b.v[num] = g.pos - val - val2;
				g.b.v[num + 1] = g.pos + val - val2;
				g.b.v[num + 2] = g.pos + val + val2;
				g.b.v[num + 3] = g.pos - val + val2;
				g.b.dirty = true;
			}

			private static void GrowTick(float now)
			{
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				for (int num = grows.Count - 1; num >= 0; num--)
				{
					Grow grow = grows[num];
					if (grow.quad >= grow.b.quads || grow.b.meta[grow.quad].w <= 0f)
					{
						grows.RemoveAt(num);
					}
					else
					{
						float num2 = Mathf.Clamp01((now - grow.born) / grow.dur);
						WriteGrow(grow, Mathf.Lerp(grow.s0, grow.s1, 1f - (1f - num2) * (1f - num2)));
						if (num2 >= 1f)
						{
							grows.RemoveAt(num);
						}
					}
				}
			}

			public static string Census()
			{
				int num = 0;
				foreach (Bucket value in buckets.Values)
				{
					num += value.quads;
				}
				return $"splats {num}q/{buckets.Count}b (+{grows.Count} growing)";
			}

			public static void EraseSphere(Vector3 pos, float r)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: 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_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: 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_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: 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)
				float num = r * r;
				foreach (Bucket value2 in buckets.Values)
				{
					if (!value2.hasBounds || pos.x < value2.bMin.x - r || pos.x > value2.bMax.x + r || pos.y < value2.bMin.y - r || pos.y > value2.bMax.y + r || pos.z < value2.bMin.z - r || pos.z > value2.bMax.z + r)
					{
						continue;
					}
					for (int i = 0; i < value2.quads; i++)
					{
						Vector4 val = value2.meta[i];
						if (!(val.w <= 0f))
						{
							Vector3 val2 = new Vector3(val.x, val.y, val.z) - pos;
							if (!(((Vector3)(ref val2)).sqrMagnitude > num))
							{
								int num2 = i * 4;
								Vector3 value = value2.v[num2];
								value2.v[num2 + 1] = value;
								value2.v[num2 + 2] = value;
								value2.v[num2 + 3] = value;
								value2.meta[i] = new Vector4(val.x, val.y, val.z, -1f);
								value2.dirty = true;
							}
						}
					}
				}
			}

			private static void Compact(Bucket b)
			{
				int num = b.quads / 4;
				b.v.RemoveRange(0, num * 4);
				b.n.RemoveRange(0, num * 4);
				b.meta.RemoveRange(0, num);
				b.quads -= num;
				b.tri.Clear();
				for (int i = 0; i < b.quads; i++)
				{
					int num2 = i * 4;
					b.tri.Add(num2);
					b.tri.Add(num2 + 1);
					b.tri.Add(num2 + 2);
					b.tri.Add(num2);
					b.tri.Add(num2 + 2);
					b.tri.Add(num2 + 3);
				}
				b.dirty = true;
				for (int num3 = grows.Count - 1; num3 >= 0; num3--)
				{
					Grow grow = grows[num3];
					if (grow.b == b)
					{
						grow.quad -= num;
						if (grow.quad < 0)
						{
							grows.RemoveAt(num3);
						}
					}
				}
			}

			private static Bucket GetBucket(int palette)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Expected O, but got Unknown
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				if (buckets.TryGetValue(palette, out var value))
				{
					return value;
				}
				Material material = GetMaterial(palette);
				if ((Object)(object)material == (Object)null)
				{
					return null;
				}
				if ((Object)(object)root == (Object)null)
				{
					root = new GameObject("ScorchedVoxelsBlood");
				}
				value = new Bucket();
				value.go = new GameObject("blood" + palette);
				value.go.transform.SetParent(root.transform, false);
				MeshFilter val = value.go.AddComponent<MeshFilter>();
				MeshRenderer obj = value.go.AddComponent<MeshRenderer>();
				value.mesh = new Mesh
				{
					name = "blood" + palette
				};
				value.mesh.MarkDynamic();
				val.sharedMesh = value.mesh;
				((Renderer)obj).sharedMaterial = material;
				((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				buckets[palette] = value;
				return value;
			}

			public static IEnumerable<KeyValuePair<int, Material>> DebugMaterials()
			{
				return materials;
			}

			public static Material GetMaterial(int palette)
			{
				//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_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: 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)
				if (materials.TryGetValue(palette, out var value) && (Object)(object)value != (Object)null)
				{
					return value;
				}
				Shader val = FindShaderSafe("Hopoo Games/Deferred/Standard", "Standard", "Sprites/Default");
				if ((Object)(object)val == (Object)null)
				{
					if (!shaderWarned)
					{
						shaderWarned = true;
						ScorchedVoxelsPlugin.Log.LogWarning((object)"GoreSystem: no usable shader for blood decals — blood disabled, corpses unaffected.");
					}
					return null;
				}
				bool flag = (palette & 0x10) != 0;
				Palette palette2 = Palettes[Mathf.Clamp(palette & -17, 0, Palettes.Length - 1)];
				Material val2 = new Material(val)
				{
					name = "GoreBlood" + palette,
					color = palette2.color
				};
				float num = (flag ? 0.95f : (palette2.matte ? 0.15f : 0.62f));
				if (val2.HasProperty("_Smoothness"))
				{
					val2.SetFloat("_Smoothness", num);
				}
				if (val2.HasProperty("_Glossiness"))
				{
					val2.SetFloat("_Glossiness", num);
				}
				Color emission = palette2.emission;
				if (((Color)(ref emission)).maxColorComponent > 0f && val2.HasProperty("_EmissionColor"))
				{
					val2.EnableKeyword("_EMISSION");
					val2.SetColor("_EmissionColor", palette2.emission);
				}
				else if (flag && val2.HasProperty("_EmissionColor"))
				{
					val2.EnableKeyword("_EMISSION");
					val2.SetColor("_EmissionColor", new Color(0.3f, 0.08f, 0.55f));
				}
				materials[palette] = val2;
				return val2;
			}
		}

		private static class Stains
		{
			private class Patch
			{
				public int vStart;

				public int vCount;

				public int tStart;

				public int tCount;

				public Vector3 center;

				public float radius;
			}

			private class Bucket
			{
				public GameObject go;

				public Mesh mesh;

				public readonly List<Vector3> v = new List<Vector3>(18000);

				public readonly List<Vector3> n = new List<Vector3>(18000);

				public readonly List<int> tri = new List<int>(54000);

				public readonly List<Patch> patches = new List<Patch>();

				public bool dirty;

				public float nextUploadAt;

				public Vector3 bMin;

				public Vector3 bMax;

				public bool hasBounds;

				public float maxR;
			}

			private const int MaxVertsPerBucket = 18000;

			private static readonly Dictionary<int, Bucket> buckets = new Dictionary<int, Bucket>();

			private static readonly Dictionary<int, Material> fleshMats = new Dictionary<int, Material>();

			private static GameObject root;

			private static readonly Bounds HugeBounds = new Bounds(Vector3.zero, Vector3.one * 4000f);

			private static readonly Dictionary<int, Material> boneMats = new Dictionary<int, Material>();

			public static void Reset()
			{
				foreach (Bucket value in buckets.Values)
				{
					if ((Object)(object)value.mesh != (Object)null)
					{
						Object.Destroy((Object)(object)value.mesh);
					}
				}
				buckets.Clear();
				if ((Object)(object)root != (Object)null)
				{
					Object.Destroy((Object)(object)root);
				}
				root = null;
			}

			public static void Tick()
			{
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				float time = Time.time;
				foreach (Bucket value in buckets.Values)
				{
					if (value.dirty && !((Object)(object)value.mesh == (Object)null) && !(time < value.nextUploadAt))
					{
						value.nextUploadAt = time + UploadThrottle(value.v.Count);
						value.mesh.Clear();
						value.mesh.SetVertices(value.v);
						value.mesh.SetNormals(value.n);
						value.mesh.SetTriangles(value.tri, 0, false, 0);
						value.mesh.bounds = HugeBounds;
						value.dirty = false;
						break;
					}
				}
			}

			public static void AddPatch(int palette, List<Vector3> verts, List<Vector3> normals, List<int> tris, Vector3 center, float radius)
			{
				//IL_006a: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: 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_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				Bucket bucket = GetBucket(palette);
				if (bucket == null)
				{
					return;
				}
				if (bucket.v.Count + verts.Count > 18000)
				{
					Compact(bucket);
				}
				Patch patch = new Patch
				{
					vStart = bucket.v.Count,
					vCount = verts.Count,
					tStart = bucket.tri.Count,
					tCount = tris.Count,
					center = center,
					radius = radius
				};
				bucket.v.AddRange(verts);
				bucket.n.AddRange(normals);
				foreach (int tri in tris)
				{
					bucket.tri.Add(tri + patch.vStart);
				}
				bucket.patches.Add(patch);
				if (!bucket.hasBounds)
				{
					bucket.bMin = center;
					bucket.bMax = center;
					bucket.hasBounds = true;
				}
				else
				{
					bucket.bMin = Vector3.Min(bucket.bMin, center);
					bucket.bMax = Vector3.Max(bucket.bMax, center);
				}
				if (radius > bucket.maxR)
				{
					bucket.maxR = radius;
				}
				bucket.dirty = true;
			}

			public static string Census()
			{
				int num = 0;
				int num2 = 0;
				foreach (Bucket value in buckets.Values)
				{
					num += value.v.Count;
					num2 += value.patches.Count;
				}
				return $"stains {num}v/{num2}p/{buckets.Count}b";
			}

			public static void EraseSphere(Vector3 pos, float r)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_013a: Unknown result type (might be due to invalid IL or missing references)
				foreach (Bucket value2 in buckets.Values)
				{
					float num = r + value2.maxR;
					if (!value2.hasBounds || pos.x < value2.bMin.x - num || pos.x > value2.bMax.x + num || pos.y < value2.bMin.y - num || pos.y > value2.bMax.y + num || pos.z < value2.bMin.z - num || pos.z > value2.bMax.z + num)
					{
						continue;
					}
					foreach (Patch patch in value2.patches)
					{
						if (patch.radius <= 0f)
						{
							continue;
						}
						float num2 = r + patch.radius;
						Vector3 val = patch.center - pos;
						if (!(((Vector3)(ref val)).sqrMagnitude > num2 * num2))
						{
							Vector3 value = value2.v[patch.vStart];
							for (int i = 1; i < patch.vCount; i++)
							{
								value2.v[patch.vStart + i] = value;
							}
							patch.radius = -1f;
							value2.dirty = true;
						}
					}
				}
			}

			private static void Compact(Bucket b)
			{
				int num = Mathf.Max(b.patches.Count / 2, 1);
				if (num >= b.patches.Count)
				{
					b.v.Clear();
					b.n.Clear();
					b.tri.Clear();
					b.patches.Clear();
					b.dirty = true;
					return;
				}
				int vStart = b.patches[num].vStart;
				int tStart = b.patches[num].tStart;
				b.v.RemoveRange(0, vStart);
				b.n.RemoveRange(0, vStart);
				b.tri.RemoveRange(0, tStart);
				for (int i = 0; i < b.tri.Count; i++)
				{
					b.tri[i] -= vStart;
				}
				b.patches.RemoveRange(0, num);
				foreach (Patch patch in b.patches)
				{
					patch.vStart -= vStart;
					patch.tStart -= tStart;
				}
				b.dirty = true;
			}

			private static Bucket GetBucket(int palette)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Expected O, but got Unknown
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				if (buckets.TryGetValue(palette, out var value))
				{
					return value;
				}
				Material material = Splats.GetMaterial(palette);
				if ((Object)(object)material == (Object)null)
				{
					return null;
				}
				if ((Object)(object)root == (Object)null)
				{
					root = new GameObject("ScorchedVoxelsStains");
				}
				value = new Bucket();
				value.go = new GameObject("stain" + palette);
				value.go.transform.SetParent(root.transform, false);
				MeshFilter val = value.go.AddComponent<MeshFilter>();
				MeshRenderer obj = value.go.AddComponent<MeshRenderer>();
				value.mesh = new Mesh
				{
					name = "stain" + palette
				};
				value.mesh.MarkDynamic();
				val.sharedMesh = value.mesh;
				((Renderer)obj).sharedMaterial = material;
				((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				buckets[palette] = value;
				return value;
			}

			public static IEnumerable<KeyValuePair<int, Material>> DebugFleshMaterials()
			{
				return fleshMats;
			}

			public static IEnumerable<KeyValuePair<int, Material>> DebugBoneMaterials()
			{
				return boneMats;
			}

			public static Material BoneMaterial(int palette)
			{
				//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_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: 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_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				if (boneMats.TryGetValue(palette, out var value) && (Object)(object)value != (Object)null)
				{
					return value;
				}
				Material material = Splats.GetMaterial(palette);
				if ((Object)(object)material == (Object)null)
				{
					return null;
				}
				Palette palette2 = Palettes[Mathf.Clamp(palette & -17, 0, Palettes.Length - 1)];
				Color bone = palette2.bone;
				bone.a = 1f;
				Material val = new Material(material)
				{
					name = "GoreBone" + palette,
					color = bone
				};
				if (val.HasProperty("_Smoothness"))
				{
					val.SetFloat("_Smoothness", palette2.boneGloss);
				}
				if (val.HasProperty("_Glossiness"))
				{
					val.SetFloat("_Glossiness", palette2.boneGloss);
				}
				val.DisableKeyword("_EMISSION");
				if (val.HasProperty("_EmissionColor"))
				{
					val.SetColor("_EmissionColor", Color.black);
				}
				boneMats[palette] = val;
				return val;
			}

			public static Material FleshMaterial(int palette)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: 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_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Expected O, but got Unknown
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: 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_0125: Unknown result type (might be due to invalid IL or missing references)
				if (fleshMats.TryGetValue(palette, out var value) && (Object)(object)value != (Object)null)
				{
					return value;
				}
				Material material = Splats.GetMaterial(palette);
				if ((Object)(object)material == (Object)null)
				{
					return null;
				}
				Color val = Palettes[Mathf.Clamp(palette & -17, 0, Palettes.Length - 1)].color * 0.72f;
				float num = Mathf.Max(val.r, Mathf.Max(val.g, val.b));
				if (num > 0.0001f && num < 0.18f)
				{
					val *= 0.18f / num;
				}
				val.a = 1f;
				Material val2 = new Material(material)
				{
					name = "GoreFlesh" + palette,
					color = val
				};
				if (val2.HasProperty("_Smoothness"))
				{
					val2.SetFloat("_Smoothness", 0.2f);
				}
				if (val2.HasProperty("_Glossiness"))
				{
					val2.SetFloat("_Glossiness", 0.2f);
				}
				val2.DisableKeyword("_EMISSION");
				if (val2.HasProperty("_EmissionColor"))
				{
					val2.SetColor("_EmissionColor", Color.black);
				}
				fleshMats[palette] = val2;
				return val2;
			}
		}

		private static class Sparks
		{
			public readonly struct MoteStyle
			{
				public readonly Color32 color;

				public readonly float rise;

				public readonly float jitter;

				public readonly float grav;

				public readonly float sizeMin;

				public readonly float sizeMax;

				public readonly float ttlMin;

				public readonly float ttlMax;

				public readonly float twinkle;

				public MoteStyle(byte r, byte g, byte b, float rise, float jitter, float grav, float sizeMin, float sizeMax, float ttlMin, float ttlMax, float twinkle)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					color = new Color32(r, g, b, byte.MaxValue);
					this.rise = rise;
					this.jitter = jitter;
					this.grav = grav;
					this.sizeMin = sizeMin;
					this.sizeMax = sizeMax;
					this.ttlMin = ttlMin;
					this.ttlMax = ttlMax;
					this.twinkle = twinkle;
				}
			}

			private struct Spark
			{
				public Vector3 pos;

				public Vector3 pos2;

				public Vector3 vel;

				public Vector3 ax;

				public Vector3 ay;

				public float born;

				public float ttl;

				public float size;

				public float phase;

				public Color32 color;

				public float grav;

				public float twinkleRate;

				public bool arc;
			}

			private const int MaxSparks = 640;

			public static readonly MoteStyle VoidMote = new MoteStyle(98, 23, byte.MaxValue, 0.45f, 0.25f, 0f, 0.07f, 0.18f, 0.55f, 1.1f, 20f);

			public static readonly MoteStyle Ember = new MoteStyle(byte.MaxValue, 128, 26, 0.9f, 0.5f, 0.3f, 0.07f, 0.17f, 0.7f, 1.6f, 13f);

			public static readonly MoteStyle HelfireEmber = new MoteStyle(90, 140, byte.MaxValue, 1f, 0.5f, 0.35f, 0.07f, 0.18f, 0.7f, 1.6f, 13f);

			public static readonly MoteStyle AcidBubble = new MoteStyle(120, 230, 40, 0.35f, 0.3f, 0f, 0.06f, 0.15f, 0.5f, 1.1f, 24f);

			public static readonly MoteStyle BlightBubble = new MoteStyle(235, 180, 30, 0.35f, 0.3f, 0f, 0.06f, 0.15f, 0.5f, 1.1f, 24f);

			public static readonly MoteStyle FrostGlint = new MoteStyle(190, 225, byte.MaxValue, 0.05f, 0.3f, -0.5f, 0.05f, 0.13f, 1f, 2f, 30f);

			public static readonly MoteStyle ArcSpark = new MoteStyle(210, 235, byte.MaxValue, 0.2f, 3.5f, -2f, 0.05f, 0.11f, 0.12f, 0.3f, 60f);

			public static readonly MoteStyle LunarMote = new MoteStyle(150, 175, byte.MaxValue, 0.3f, 0.15f, 0f, 0.07f, 0.16f, 1f, 2f, 8f);

			public static readonly MoteStyle NanoMote = new MoteStyle(140, 210, 200, 0.25f, 0.9f, 0f, 0.05f, 0.1f, 0.3f, 0.7f, 40f);

			public static readonly MoteStyle GoldMote = new MoteStyle(byte.MaxValue, 208, 90, 0.4f, 0.3f, -0.2f, 0.06f, 0.15f, 0.6f, 1.2f, 34f);

			private static readonly List<Spark> sparks = new List<Spark>();

			public static int Peak;

			private static readonly List<Vector3> v = new List<Vector3>();

			private static readonly List<Color32> col = new List<Color32>();

			private static readonly List<int> tri = new List<int>();

			private static GameObject go;

			private static Mesh mesh;

			private static Material mat;

			private static float matNextTry;

			private static bool meshEmpty = true;

			private static readonly Bounds HugeBounds = new Bounds(Vector3.zero, Vector3.one * 4000f);

			private const float ArcStrobeRate = 90f;

			public static int Count => sparks.Count;

			public static void Reset()
			{
				sparks.Clear();
				Peak = 0;
				if ((Object)(object)mesh != (Object)null)
				{
					Object.Destroy((Object)(object)mesh);
				}
				mesh = null;
				if ((Object)(object)go != (Object)null)
				{
					Object.Destroy((Object)(object)go);
				}
				go = null;
				meshEmpty = true;
			}

			public static void Emit(int palette, Vector3 pos, int count)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if ((palette & 0x10) != 0)
				{
					EmitStyle(((palette & -17) == 11) ? GoldMote : VoidMote, pos, count);
				}
			}

			public static void EmitStyle(in MoteStyle st, Vector3 pos, int count)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: 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_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: 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_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)
				if (!EnsureMat())
				{
					return;
				}
				float time = Time.time;
				for (int i = 0; i < count; i++)
				{
					if (sparks.Count >= 640)
					{
						EvictOne();
					}
					Vector3 val = RandomInSphere();
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					val = Vector3.Cross(normalized, RandomInSphere());
					Vector3 ay = ((Vector3)(ref val)).normalized;
					if (((Vector3)(ref ay)).sqrMagnitude < 0.5f)
					{
						ay = Vector3.up;
					}
					sparks.Add(new Spark
					{
						pos = pos + RandomInSphere() * 0.3f,
						vel = Vector3.up * (st.rise * (0.7f + (float)rng.NextDouble() * 0.6f)) + RandomInSphere() * st.jitter,
						ax = normalized,
						ay = ay,
						born = time,
						ttl = st.ttlMin + (float)rng.NextDouble() * (st.ttlMax - st.ttlMin),
						size = st.sizeMin + (float)rng.NextDouble() * (st.sizeMax - st.sizeMin),
						phase = (float)rng.NextDouble() * 20f,
						color = st.color,
						grav = st.grav,
						twinkleRate = st.twinkle
					});
				}
			}

			public static void EmitImplosion(Vector3 center, int count, float radius)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: 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_008b: 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_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: 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_00cb: 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_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: 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_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)
				if (!EnsureMat())
				{
					return;
				}
				float time = Time.time;
				for (int i = 0; i < count; i++)
				{
					if (sparks.Count >= 640)
					{
						EvictOne();
					}
					Vector3 val = RandomInSphere();
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					val = Vector3.Cross(normalized, RandomInSphere());
					Vector3 ay = ((Vector3)(ref val)).normalized;
					if (((Vector3)(ref ay)).sqrMagnitude < 0.5f)
					{
						ay = Vector3.up;
					}
					val = RandomInSphere();
					Vector3 val2 = center + ((Vector3)(ref val)).normalized * (radius * (0.75f + (float)rng.NextDouble() * 0.5f));
					float num = 0.3f + (float)rng.NextDouble() * 0.25f;
					sparks.Add(new Spark
					{
						pos = val2,
						vel = (center - val2) / num,
						ax = normalized,
						ay = ay,
						born = time,
						ttl = num,
						size = VoidMote.sizeMin + (float)rng.NextDouble() * (VoidMote.sizeMax - VoidMote.sizeMin),
						phase = (float)rng.NextDouble() * 20f,
						color = VoidMote.color,
						grav = 0f,
						twinkleRate = VoidMote.twinkle
					});
				}
			}

			private static void EvictOne()
			{
				int index = sparks.Count - 1;
				sparks[0] = sparks[index];
				sparks.RemoveAt(index);
			}

			public static void EmitArc(Vector3 a, Vector3 b)
			{
				//IL_001e: 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)
				//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_003b: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: 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_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: 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_006d: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				if (EnsureMat())
				{
					if (sparks.Count >= 640)
					{
						EvictOne();
					}
					Vector3 val = RandomInSphere();
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					List<Spark> list = sparks;
					Spark item = new Spark
					{
						pos = a,
						pos2 = b,
						ax = normalized
					};
					val = Vector3.Cross(normalized, Vector3.up);
					Vector3 ay;
					if (!(((Vector3)(ref val)).sqrMagnitude > 0.1f))
					{
						ay = Vector3.right;
					}
					else
					{
						val = Vector3.Cross(normalized, Vector3.up);
						ay = ((Vector3)(ref val)).normalized;
					}
					item.ay = ay;
					item.born = Time.time;
					item.ttl = 0.2f + (float)rng.NextDouble() * 0.15f;
					item.size = 0.08f + (float)rng.NextDouble() * 0.06f;
					item.phase = (float)rng.NextDouble() * 20f;
					item.color = ArcSpark.color;
					item.twinkleRate = 90f;
					item.arc = true;
					list.Add(item);
				}
			}

			public static void Tick()
			{
				//IL_0302: Unknown result type (might be due to invalid IL or missing references)
				//IL_0267: Unknown result type (might be due to invalid IL or missing references)
				//IL_0271: Expected O, but got Unknown
				//IL_0287: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_029c: Expected O, but got Unknown
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: 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_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: 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_01c0: 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_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: 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_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0220: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0232: 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_023e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Unknown result type (might be due to invalid IL or missing references)
				if (sparks.Count > Peak)
				{
					Peak = sparks.Count;
				}
				if (sparks.Count == 0)
				{
					if (!meshEmpty && (Object)(object)mesh != (Object)null)
					{
						mesh.Clear();
						meshEmpty = true;
					}
					return;
				}
				float time = Time.time;
				float deltaTime = Time.deltaTime;
				v.Clear();
				col.Clear();
				tri.Clear();
				for (int num = sparks.Count - 1; num >= 0; num--)
				{
					Spark s = sparks[num];
					float num2 = (time - s.born) / s.ttl;
					if (num2 >= 1f)
					{
						int index = sparks.Count - 1;
						sparks[num] = sparks[index];
						sparks.RemoveAt(index);
					}
					else if (s.arc)
					{
						DrawArc(in s, time, num2);
					}
					else
					{
						s.vel.y += s.grav * deltaTime;
						ref Vector3 pos = ref s.pos;
						pos += s.vel * deltaTime;
						sparks[num] = s;
						float num3 = 0.7f + 0.3f * Mathf.Sin(time * s.twinkleRate + s.phase);
						float num4 = s.size * (1f - num2) * num3;
						Color32 color = s.color;
						color.a = (byte)(255f * (1f - num2));
						AddQuad(s.pos - s.ax * num4 - s.ay * num4, s.pos + s.ax * num4 - s.ay * num4, s.pos + s.ax * num4 + s.ay * num4, s.pos - s.ax * num4 + s.ay * num4, color);
					}
				}
				if ((Object)(object)mesh == (Object)null)
				{
					go = new GameObject("ScorchedVoxelsSparks");
					MeshFilter val = go.AddComponent<MeshFilter>();
					MeshRenderer obj = go.AddComponent<MeshRenderer>();
					mesh = new Mesh
					{
						name = "voidsparks"
					};
					mesh.MarkDynamic();
					val.sharedMesh = mesh;
					((Renderer)obj).sharedMaterial = mat;
					((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				}
				mesh.Clear();
				mesh.SetVertices(v);
				mesh.SetColors(col);
				mesh.SetTriangles(tri, 0, false, 0);
				mesh.bounds = HugeBounds;
				meshEmpty = false;
			}

			private static void DrawArc(in Spark s, float now, float age)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: 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_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_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: 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_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: 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_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_010d: 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_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: 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_0143: 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_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_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: 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_017b: 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_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_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = s.pos2 - s.pos;
				float magnitude = ((Vector3)(ref val)).magnitude;
				if (!(magnitude < 0.05f))
				{
					Vector3 val2 = val / magnitude;
					Vector3 val3 = Vector3.Cross(val2, s.ax);
					if (((Vector3)(ref val3)).sqrMagnitude < 0.01f)
					{
						val3 = Vector3.Cross(val2, s.ay);
					}
					((Vector3)(ref val3)).Normalize();
					Vector3 val4 = Vector3.Cross(val2, val3);
					float num = ((Mathf.Sin(now * s.twinkleRate + s.phase) > -0.2f) ? 1f : 0.35f);
					Color32 color = s.color;
					color.a = (byte)(255f * (1f - age) * num);
					float size = s.size;
					float num2 = magnitude * 0.1f;
					Vector3 val5 = s.pos + val * 0.33f + (val3 * Mathf.Sin(now * 53f + s.phase) + val4 * Mathf.Cos(now * 47f - s.phase)) * num2;
					Vector3 val6 = s.pos + val * 0.66f + (val3 * Mathf.Sin(now * 61f - s.phase) + val4 * Mathf.Cos(now * 43f + s.phase)) * num2;
					ArcSeg(s.pos, val5, val3, size, color);
					ArcSeg(val5, val6, val3, size, color);
					ArcSeg(val6, s.pos2, val3, size, color);
				}
			}

			private static void ArcSeg(Vector3 a, Vector3 b, Vector3 side, float w, Color32 c)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: 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_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_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)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: 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_002a: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = side * (w * 0.5f);
				AddQuad(a - val, a + val, b + val, b - val, c);
			}

			private static void AddQuad(Vector3 q0, Vector3 q1, Vector3 q2, Vector3 q3, Color32 c)
			{
				//IL_0010: 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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				int count = v.Count;
				v.Add(q0);
				v.Add(q1);
				v.Add(q2);
				v.Add(q3);
				for (int i = 0; i < 4; i++)
				{
					col.Add(c);
				}
				tri.Add(count);
				tri.Add(count + 1);
				tri.Add(count + 2);
				tri.Add(count);
				tri.Add(count + 2);
				tri.Add(count + 3);
				tri.Add(count);
				tri.Add(count + 2);
				tri.Add(count + 1);
				tri.Add(count);
				tri.Add(count + 3);
				tri.Add(count + 2);
			}

			public static void Warm()
			{
				EnsureMat();
			}

			private static bool EnsureMat()
			{
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Expected O, but got Unknown
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)mat != (Object)null)
				{
					return true;
				}
				if (Time.unscaledTime < matNextTry)
				{
					return false;
				}
				matNextTry = Time.unscaledTime + 10f;
				Shader val = FindShaderSafe("Legacy Shaders/Particles/Additive", "Particles/Additive", "Sprites/Default");
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				if (ModOptions.VerboseLogging.Value)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)("GoreSystem: motes shader = '" + ((Object)val).name + "'"));
				}
				mat = new Material(val)
				{
					name = "GoreMotes"
				};
				if (mat.HasProperty("_TintColor"))
				{
					mat.SetColor("_TintColor", new Color(1f, 1f, 1f, 0.6f));
				}
				if (mat.HasProperty("_Color"))
				{
					mat.SetColor("_Color", new Color(1f, 1f, 1f, 0.9f));
				}
				return true;
			}
		}

		private static class Drops
		{
			private struct Drop
			{
				public byte kind;

				public Vector3 pos;

				public Vector3 vel;

				public Vector3 ax;

				public Vector3 ay;

				public Transform endTf;

				public Vector3 endLocal;

				public float born;

				public float ttl;

				public float size;

				public float stamp;

				public float nextWake;

				public Vector3 castFrom;

				public int palette;

				public Color32 color;
			}

			private const int MaxDrops = 512;

			private const float Gravity = 16f;

			private const float DropTTL = 2.6f;

			private const float WakeSpeedSq = 36f;

			private const float WakeStep = 0.06f;

			private const byte KDrop = 0;

			private const byte KStrand = 1;

			private const byte KPuff = 2;

			private static readonly List<Drop> drops = new List<Drop>();

			public static int Peak;

			private static readonly List<Vector3> v = new List<Vector3>();

			private static readonly List<Color32> col = new List<Color32>();

			private static readonly List<int> tri = new List<int>();

			private static GameObject go;

			private static Mesh mesh;

			private static Material mat;

			private static float matNextTry;

			private static bool meshEmpty = true;

			private static readonly Bounds HugeBounds = new Bounds(Vector3.zero, Vector3.one * 4000f);

			private const int EmitPerFrame = 160;

			private static int emitFrame = -1;

			private static int emitBudget;

			public static int Count => drops.Count;

			public static void Reset()
			{
				drops.Clear();
				Peak = 0;
				if ((Object)(object)mesh != (Object)null)
				{
					Object.Destroy((Object)(object)mesh);
				}
				mesh = null;
				if ((Object)(object)go != (Object)null)
				{
					Object.Destroy((Object)(object)go);
				}
				go = null;
				meshEmpty = true;
			}

			private static void EvictOne()
			{
				int index = drops.Count - 1;
				drops[0] = drops[index];
				drops.RemoveAt(index);
			}

			private static void RemoveAtSwap(int i)
			{
				int index = drops.Count - 1;
				drops[i] = drops[index];
				drops.RemoveAt(index);
			}

			private static bool TakeEmit()
			{
				int frameCount = Time.frameCount;
				if (frameCount != emitFrame)
				{
					emitFrame = frameCount;
					emitBudget = 160;
				}
				if (emitBudget <= 0)
				{
					return false;
				}
				emitBudget--;
				return true;
			}

			private static Color32 BloodColor(int palette)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: 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_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: 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)
				Color val = Palettes[Mathf.Clamp(palette & -17, 0, Palettes.Length - 1)].color * 1.25f;
				return new Color32((byte)(Mathf.Clamp01(val.r) * 255f), (byte)(Mathf.Clamp01(val.g) * 255f), (byte)(Mathf.Clamp01(val.b) * 255f), (byte)235);
			}

			public static void EmitBurst(Vector3 origin, Vector3 dir, int count, float len, float sizeMin, float sizeMax, int palette, float coneDeg)
			{
				//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_0016: 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_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_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_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: 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_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_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: 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_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				if (!EnsureMat())
				{
					return;
				}
				if (((Vector3)(ref dir)).sqrMagnitude < 0.001f)
				{
					dir = Vector3.down;
				}
				((Vector3)(ref dir)).Normalize();
				float num = Mathf.Tan(coneDeg * (MathF.PI / 180f));
				Color32 color = BloodColor(palette);
				float time = Time.time;
				for (int i = 0; i < count; i++)
				{
					if (!TakeEmit())
					{
						break;
					}
					if (drops.Count >= 512)
					{
						EvictOne();
					}
					Vector3 val = RandomInSphere();
					Vector3 val2 = val - dir * Vector3.Dot(val, dir);
					Vector3 val3 = dir + val2 * num;
					Vector3 normalized = ((Vector3)(ref val3)).normalized;
					float num2 = sizeMin + (float)rng.NextDouble() * (sizeMax - sizeMin);
					Vector3 val4 = origin + normalized * 0.05f;
					drops.Add(new Drop
					{
						kind = 0,
						pos = val4,
						castFrom = val4,
						vel = normalized * (len * (1.7f + (float)rng.NextDouble() * 1.1f)),
						born = time,
						ttl = 2.6f,
						size = Mathf.Clamp(num2 * 0.5f, 0.045f, 0.22f),
						stamp = num2,
						palette = palette,
						color = color
					});
				}
			}

			public static void EmitDrip(Vector3 pos, int palette)
			{
				//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_0045: 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_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				if (EnsureMat() && TakeEmit())
				{
					if (drops.Count >= 512)
					{
						EvictOne();
					}
					drops.Add(new Drop
					{
						kind = 0,
						pos = pos,
						castFrom = pos,
						vel = RandomInSphere() * 0.6f + Vector3.down * 0.5f,
						born = Time.time,
						ttl = 2.6f,
						size = 0.05f + (float)rng.NextDouble() * 0.04f,
						stamp = 0.12f + (float)rng.NextDouble() * 0.18f,
						palette = palette,
						color = BloodColor(palette)
					});
				}
			}

			public static void EmitStrand(Vector3 from, Transform pieceTf, Vector3 endLocal, int palette, float width)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: 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_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: 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_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)
				if (EnsureMat())
				{
					if (drops.Count >= 512)
					{
						EvictOne();
					}
					Color32 color = BloodColor(palette);
					color.a = byte.MaxValue;
					drops.Add(new Drop
					{
						kind = 1,
						pos = from,
						endTf = pieceTf,
						endLocal = endLocal,
						born = Time.time,
						ttl = 0.22f + (float)rng.NextDouble() * 0.12f,
						size = width,
						palette = palette,
						color = color
					});
				}
			}

			public static void EmitPuff(Vector3 pos, int count)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: 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_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				if (!EnsureMat())
				{
					return;
				}
				float time = Time.time;
				for (int i = 0; i < count; i++)
				{
					if (drops.Count >= 512)
					{
						EvictOne();
					}
					Vector3 val = RandomInSphere();
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					val = Vector3.Cross(normalized, RandomInSphere());
					Vector3 ay = ((Vector3)(ref val)).normalized;
					if (((Vector3)(ref ay)).sqrMagnitude < 0.5f)
					{
						ay = Vector3.up;
					}
					drops.Add(new Drop
					{
						kind = 2,
						pos = pos + RandomInSphere() * 0.2f,
						vel = Vector3.up * (0.6f + (float)rng.NextDouble() * 0.4f) + RandomInSphere() * 0.25f,
						ax = normalized,
						ay = ay,
						born = time,
						ttl = 1.2f + (float)rng.NextDouble() * 0.7f,
						size = 0.16f + (float)rng.NextDouble() * 0.1f,
						stamp = 0.5f,
						color = new Color32((byte)38, (byte)36, (byte)34, (byte)110)
					});
				}
			}

			public static void Tick()
			{
				//IL_039f: 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_030e: Expected O, but got Unknown
				//IL_0324: 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_0339: Expected O, but got Unknown
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_028d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: 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_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				if (drops.Count > Peak)
				{
					Peak = drops.Count;
				}
				if (drops.Count == 0)
				{
					if (!meshEmpty && (Object)(object)mesh != (Object)null)
					{
						mesh.Clear();
						meshEmpty = true;
					}
					return;
				}
				float time = Time.time;
				float deltaTime = Time.deltaTime;
				v.Clear();
				col.Clear();
				tri.Clear();
				for (int num = drops.Count - 1; num >= 0; num--)
				{
					Drop d = drops[num];
					float num2 = (time - d.born) / d.ttl;
					if (num2 >= 1f)
					{
						if (d.kind == 1)
						{
							SnapStrand(in d, time);
						}
						RemoveAtSwap(num);
					}
					else
					{
						switch (d.kind)
						{
						case 0:
						{
							ref Vector3 pos2 = ref d.pos;
							pos2 += d.vel * deltaTime;
							d.vel.y -= 16f * deltaTime;
							if (((num + Time.frameCount) & 1) == 0)
							{
								Vector3 val = d.pos - d.castFrom;
								float magnitude = ((Vector3)(ref val)).magnitude;
								if (magnitude > 1E-05f && BloodRay(d.castFrom, val / magnitude, magnitude + 0.02f, out var hit))
								{
									Splats.Add(((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, d.stamp * (0.8f + (float)rng.NextDouble() * 0.4f), d.palette);
									if (d.stamp > 0.3f && rng.Next(3) == 0)
									{
										StainVoxels(((RaycastHit)(ref hit)).point, d.stamp * 1.6f, d.palette);
									}
									RemoveAtSwap(num);
									break;
								}
								d.castFrom = d.pos;
							}
							if (((Vector3)(ref d.vel)).sqrMagnitude > 36f && time >= d.nextWake)
							{
								d.nextWake = time + 0.06f;
								AddWake(in d, time);
							}
							drops[num] = d;
							DrawDrop(in d, num2);
							break;
						}
						case 1:
							if ((Object)(object)d.endTf == (Object)null)
							{
								RemoveAtSwap(num);
							}
							else
							{
								DrawStrand(in d, num2);
							}
							break;
						case 2:
						{
							ref Vector3 vel = ref d.vel;
							vel *= 1f - 1.6f * deltaTime;
							d.vel.y += d.stamp * deltaTime;
							ref Vector3 pos = ref d.pos;
							pos += d.vel * deltaTime;
							drops[num] = d;
							DrawPuff(in d, num2);
							break;
						}
						}
					}
				}
				if ((Object)(object)mesh == (Object)null)
				{
					go = new GameObject("ScorchedVoxelsDrops");
					MeshFilter val2 = go.AddComponent<MeshFilter>();
					MeshRenderer obj = go.AddComponent<MeshRenderer>();
					mesh = new Mesh
					{
						name = "goredrops"
					};
					mesh.MarkDynamic();
					val2.sharedMesh = mesh;
					((Renderer)obj).sharedMaterial = mat;
					((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				}
				mesh.Clear();
				mesh.SetVertices(v);
				mesh.SetColors(col);
				mesh.SetTriangles(tri, 0, false, 0);
				mesh.bounds = HugeBounds;
				meshEmpty = false;
			}

			private static void SnapStrand(in Drop d, float now)
			{
				//IL_0016: 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_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: 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_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)d.endTf == (Object)null)
				{
					return;
				}
				Vector3 val = d.endTf.TransformPoint(d.endLocal);
				for (int i = 0; i < 2; i++)
				{
					if (drops.Count >= 512)
					{
						break;
					}
					drops.Add(new Drop
					{
						kind = 0,
						pos = val,
						castFrom = val,
						vel = RandomInSphere() * 1.4f + Vector3.down * 0.6f,
						born = now,
						ttl = 2.6f,
						size = 0.05f,
						stamp = 0.14f,
						palette = d.palette,
						color = d.color
					});
				}
			}

			private static void AddWake(in Drop d, float now)
			{
				//IL_0012: 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_001a: 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_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: 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_007d: 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_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_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_00fa: 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_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)
				if (drops.Count < 512)
				{
					Vector3 val = RandomInSphere();
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					val = Vector3.Cross(normalized, RandomInSphere());
					Vector3 ay = ((Vector3)(ref val)).normalized;
					if (((Vector3)(ref ay)).sqrMagnitude < 0.5f)
					{
						ay = Vector3.up;
					}
					Color32 color = d.color;
					color.a = 88;
					drops.Add(new Drop
					{
						kind = 2,
						pos = d.pos,
						vel = d.vel * 0.12f,
						ax = normalized,
						ay = ay,
						born = now,
						ttl = 0.28f + (float)rng.NextDouble() * 0.14f,
						size = d.size * (0.9f + (float)rng.NextDouble() * 0.5f),
						stamp = -0.6f,
						color = color
					});
				}
			}

			private static void DrawDrop(in Drop d, float age)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: 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_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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_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_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: 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_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_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: 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_0128: 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_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: 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_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: 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_015c: 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_0163: 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_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_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_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_019a: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_01ae: 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_01b8: 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_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = d.vel;
				float magnitude = ((Vector3)(ref val)).magnitude;
				val = ((magnitude > 0.05f) ? (val / magnitude) : Vector3.down);
				float num = d.size * (1f + 0.45f * age);
				float num2 = num * Mathf.Clamp(1.6f + magnitude * 0.12f, 1.8f, 3.4f);
				Vector3 val2 = Vector3.Cross(val, Vector3.up);
				if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
				{
					val2 = Vector3.Cross(val, Vector3.right);
				}
				((Vector3)(ref val2)).Normalize();
				Vector3 val3 = Vector3.Cross(val, val2);
				Color32 color = d.color;
				color.a = (byte)((float)(int)color.a * (1f - 0.5f * age));
				AddQuad(d.pos - val * num2 - val2 * num, d.pos + val * num2 - val2 * num, d.pos + val * num2 + val2 * num, d.pos - val * num2 + val2 * num, color);
				AddQuad(d.pos - val * num2 - val3 * num, d.pos + val * num2 - val3 * num, d.pos + val * num2 + val3 * num, d.pos - val * num2 + val3 * num, color);
			}

			private static void DrawStrand(in Drop d, float age)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//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_0019: 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)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: 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_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_0079: 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_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: 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_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_00e3: 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_00e6: 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_008e: 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)
				Vector3 pos = d.pos;
				Vector3 val = d.endTf.TransformPoint(d.endLocal);
				Vector3 val2 = val - pos;
				float magnitude = ((Vector3)(ref val2)).magnitude;
				if (!(magnitude < 0.02f) && !(magnitude > 6f))
				{
					Vector3 val3 = pos + val2 * 0.5f + Vector3.down * (magnitude * (0.12f + 0.5f * age * age));
					Vector3 side = Vector3.Cross(val2 / magnitude, Vector3.up);
					if (((Vector3)(ref side)).sqrMagnitude < 0.01f)
					{
						side = Vector3.right;
					}
					((Vector3)(ref side)).Normalize();
					Color32 color = d.color;
					color.a = (byte)(255f * (1f - age * 0.55f));
					float w = d.size * (1f - 0.4f * age);
					StrandSeg(pos, val3, side, w, color);
					StrandSeg(val3, val, side, w, color);
				}
			}

			private static void StrandSeg(Vector3 a, Vector3 b, Vector3 side, float w, Color32 c)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: 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_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: 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_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_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)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: 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_002a: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = side * (w * 0.5f);
				AddQuad(a - val, a + val, b + val, b - val, c);
			}

			private static void DrawPuff(in Drop d, float age)
			{
				//IL_0016: 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_001e: 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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: 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_006e: 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_0085: 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_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00ad: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: 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: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: 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_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0177: Unknown result type (might be due to invalid IL or missing references)
				float num = d.size * (0.6f + 1.9f * age);
				Color32 color = d.color;
				color.a = (byte)((float)(int)color.a * (1f - age));
				Vector3 val = Vector3.Cross(d.ax, d.ay);
				AddQuad(d.pos - d.ax * num - d.ay * num, d.pos + d.ax * num - d.ay * num, d.pos + d.ax * num + d.ay * num, d.pos - d.ax * num + d.ay * num, color);
				AddQuad(d.pos - d.ay * num - val * num, d.pos + d.ay * num - val * num, d.pos + d.ay * num + val * num, d.pos - d.ay * num + val * num, color);
			}

			private static void AddQuad(Vector3 q0, Vector3 q1, Vector3 q2, Vector3 q3, Color32 c)
			{
				//IL_0010: 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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				int count = v.Count;
				v.Add(q0);
				v.Add(q1);
				v.Add(q2);
				v.Add(q3);
				for (int i = 0; i < 4; i++)
				{
					col.Add(c);
				}
				tri.Add(count);
				tri.Add(count + 1);
				tri.Add(count + 2);
				tri.Add(count);
				tri.Add(count + 2);
				tri.Add(count + 3);
				tri.Add(count);
				tri.Add(count + 2);
				tri.Add(count + 1);
				tri.Add(count);
				tri.Add(count + 3);
				tri.Add(count + 2);
			}

			public static void Warm()
			{
				EnsureMat();
			}

			private static bool EnsureMat()
			{
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Expected O, but got Unknown
				//IL_00cc: 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)
				if ((Object)(object)mat != (Object)null)
				{
					return true;
				}
				if (Time.unscaledTime < matNextTry)
				{
					return false;
				}
				matNextTry = Time.unscaledTime + 10f;
				Shader val = FindShaderSafe("Legacy Shaders/Particles/Alpha Blended", "Particles/Alpha Blended", "Sprites/Default");
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				if (ModOptions.VerboseLogging.Value)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)("GoreSystem: drops shader = '" + ((Object)val).name + "'"));
				}
				mat = new Material(val)
				{
					name = "GoreDrops"
				};
				if (mat.HasProperty("_TintColor"))
				{
					mat.SetColor("_TintColor", new Color(0.5f, 0.5f, 0.5f, 0.5f));
				}
				if (mat.HasProperty("_Color"))
				{
					mat.SetColor("_Color", Color.white);
				}
				return true;
			}
		}

		private const float BlastMatchWindow = 0.3f;

		private const float SlabMatchWindow = 0.45f;

		internal const byte KindNone = 0;

		internal const byte KindBlast = 1;

		internal const byte KindSlice = 2;

		internal const byte KindBullet = 3;

		internal const byte ElemNone = 0;

		internal const byte ElemFire = 1;

		internal const byte ElemHelfire = 2;

		internal const byte ElemAcid = 3;

		internal const byte ElemBlight = 4;

		internal const byte ElemIce = 5;

		internal const byte ElemLightning = 6;

		internal const byte ElemVoid = 7;

		internal const byte ElemLunar = 8;

		internal const byte ElemNano = 9;

		internal const int ShinyPalette = 16;

		internal const int PalAcid = 7;

		internal const int PalBlight = 8;

		internal const int PalIce = 9;

		internal const int PalScorch = 10;

		internal const int PalGold = 11;

		internal const int PalOil = 1;

		private static readonly Palette[] Palettes = new Palette[12]
		{
			new Palette(0.42f, 0.025f, 0.025f),
			new Palette(0.09f, 0.08f, 0.07f, matte: false, 0.13f, 0.13f, 0.16f, 0.75f),
			new Palette(0.42f, 0.36f, 0.28f, matte: true, 0.22f, 0.2f, 0.17f, 0.15f),
			new Palette(0.1f, 0.45f, 0.5f, matte: false, 0.62f, 0.78f, 0.82f, 0.8f),
			new Palette(0.3f, 0.42f, 0.06f, matte: false, 0.16f, 0.11f, 0.05f, 0.55f),
			new Palette(0.09f, 0.09f, 0.1f, matte: true, 0.07f, 0.07f, 0.08f, 0.2f),
			new Palette(0.24f, 0.05f, 0.3f, matte: false, 0.1f, 0.02f, 0.16f, 0.7f),
			new Palette(0.16f, 0.5f, 0.06f, matte: false, 0.78f, 0.74f, 0.62f, 0.6f, 0.1f, 0.42f, 0.03f),
			new Palette(0.55f, 0.42f, 0.06f, matte: false, 0.78f, 0.74f, 0.62f, 0.6f, 0.4f, 0.26f, 0.02f),
			new Palette(0.7f, 0.84f, 0.95f, matte: false, 0.75f, 0.85f, 0.95f, 0.9f, 0.05f, 0.11f, 0.2f),
			new Palette(0.07f, 0.055f, 0.05f, matte: true, 0.1f, 0.09f, 0.08f, 0.15f, 0.3f, 0.07f),
			new Palette(0.85f, 0.62f, 0.14f, matte: false, 0.9f, 0.72f, 0.3f, 0.95f, 0.45f, 0.28f, 0.04f)
		};

		private static readonly BloodEntry[] BloodTable = new BloodEntry[21]
		{
			new BloodEntry("Lunar", 3),
			new BloodEntry("Drone", 1),
			new BloodEntry("Turret", 1),
			new BloodEntry("Missile", 1),
			new BloodEntry("RoboBall", 1),
			new BloodEntry("Construct", 1),
			new BloodEntry("Bell", 1),
			new BloodEntry("Golem", 2),
			new BloodEntry("TitanGold", 11),
			new BloodEntry("Halcyon", 11),
			new BloodEntry("Titan", 2),
			new BloodEntry("Gravekeeper", 2),
			new BloodEntry("Wisp", 5),
			new BloodEntry("Parent", 5),
			new BloodEntry("Jellyfish", 3),
			new BloodEntry("Vagrant", 3),
			new BloodEntry("Beetle", 4),
			new BloodEntry("Larva", 4),
			new BloodEntry("Imp", 6),
			new BloodEntry("Nullifier", 6),
			new BloodEntry("Void", 6)
		};

		private static readonly RecentBlast[] recentBlasts = new RecentBlast[24];

		private static readonly RecentSlab[] recentSlabs = new RecentSlab[24];

		private static int recentBlastCursor;

		private static int recentSlabCursor;

		private static float lastHitRelay;

		private static float lastHitRequest;

		private static readonly Random rng = new Random(-1325345299);

		private static float nextCensusAt;

		private static readonly Dictionary<string, float> warnNextAt = new Dictionary<string, float>();

		private static readonly DotIndex[] DotPriority;

		private static float lastWoundRelay;

		private const float LiveBiteFloorFrac = 0.01f;

		private const float LiveBiteBigCoef = 2.5f;

		private const float LiveBiteBigFrac = 0.25f;

		private const double LiveBiteChance = 0.02;

		private const double LiveBiteBigChance = 0.1;

		private static readonly List<Vector3> stainSp;

		private static readonly List<Vector3> stainSn;

		private static readonly List<int> stainSi;

		private static readonly List<Vector3> patchV;

		private static readonly List<Vector3> patchN;

		private static readonly List<int> patchT;

		private static readonly Dictionary<int, int> patchMap;

		private const int MaxStainTris = 520;

		private static readonly Queue<StainReq> stainQueue;

		private const int MaxQueuedStains = 24;

		private const double StainBudgetMs = 2.5;

		private const int MaxStainChunks = 8;

		private static StainJob activeStain;

		private static readonly List<RecentStain> recentStains;

		private const int BurstRaysPerFrame = 96;

		private static int burstRayFrame;

		private static int burstRayBudget;

		internal static bool Active
		{
			get
			{
				if (ModOptions.Enabled.Value)
				{
					return ModOptions.GoreEnabled.Value;
				}
				return false;
			}
		}

		private static float BloodScale => Mathf.Clamp(VoxelTerrainManager.EffBloodAmount, 0.25f, 4f);

		private static int BloodFor(string bodyName)
		{
			if (string.IsNullOrEmpty(bodyName))
			{
				return 0;
			}
			BloodEntry[] bloodTable = BloodTable;
			for (int i = 0; i < bloodTable.Length; i++)
			{
				BloodEntry bloodEntry = bloodTable[i];
				if (bodyName.IndexOf(bloodEntry.fragment, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return bloodEntry.palette;
				}
			}
			return 0;
		}

		internal static int PaletteForBody(CharacterBody body)
		{
			int num = BloodFor(((Object)body).name);
			try
			{
				if (body.HasBuff(Buffs.EliteAurelionite))
				{
					num = 11;
				}
			}
			catch
			{
			}
			if (body.isElite)
			{
				num |= 0x10;
			}
			return num;
		}

		public static void Init()
		{
			GlobalEventManager.onCharacterDeathGlobal += OnCharacterDeathServer;
			GlobalEventManager.onServerDamageDealt += OnServerDamageDealtServer;
			CharacterBody.onBodyStartGlobal += OnBodyStartWarm;
		}

		private static void OnBodyStartWarm(CharacterBody body)
		{
			try
			{
				if (Active && !((Object)(object)body == (Object)null))
				{
					GoreSkeleton.QueueBake(body);
				}
			}
			catch
			{
			}
		}

		public static void WarmUp()
		{
			if (!Active)
			{
				return;
			}
			try
			{
				for (int i = 0; i <= 11; i++)
				{
					Splats.GetMaterial(i);
					Splats.GetMaterial(i | 0x10);
					Stains.FleshMaterial(i);
					Stains.BoneMaterial(i);
				}
				Drops.Warm();
				Sparks.Warm();
				GoreSkeleton.WarmCutPath();
			}
			catch (Exception e)
			{
				WarnThrottled("gore warmup", e);
			}
		}

		internal static float OverkillBoost(uint overkill)
		{
			float num = (float)overkill / 64f;
			return 1f + Mathf.Min(Mathf.Max(num - 1f, 0f) * 0.15f, 0.6f);
		}

		public static void Reset()
		{
			Array.Clear(recentBlasts, 0, recentBlasts.Length);
			Array.Clear(recentSlabs, 0, recentSlabs.Length);
			stainQueue.Clear();
			activeStain = null;
			recentStains.Clear();
			GoreSkeleton.Reset();
			GoreWounds.Reset();
			GoreDebug.Reset();
			Splats.Reset();
			Stains.Reset();
			Sparks.Reset();
			Drops.Reset();
		}

		public static void Tick()
		{
			try
			{
				GoreSkeleton.Tick();
			}
			catch (Exception e)
			{
				WarnThrottled("GoreSkeleton tick", e);
			}
			long t = GoreProf.Begin();
			try
			{
				Drops.Tick();
			}
			catch (Exception e2)
			{
				WarnThrottled("Blood drops tick", e2);
			}
			GoreProf.End(27, t);
			t = GoreProf.Begin();
			try
			{
				Splats.Tick();
			}
			catch (Exception e3)
			{
				WarnThrottled("Blood splats tick", e3);
			}
			GoreProf.End(28, t);
			t = GoreProf.Begin();
			try
			{
				DrainStainQueue();
			}
			catch (Exception e4)
			{
				WarnThrottled("Blood stains drain", e4);
			}
			GoreProf.End(29, t);
			t = GoreProf.Begin();
			try
			{
				Stains.Tick();
			}
			catch (Exception e5)
			{
				WarnThrottled("Blood stains tick", e5);
			}
			GoreProf.End(32, t);
			t = GoreProf.Begin();
			try
			{
				Sparks.Tick();
			}
			catch (Exception e6)
			{
				WarnThrottled("Void sparks tick", e6);
			}
			GoreProf.End(30, t);
			t = GoreProf.Begin();
			try
			{
				GoreWounds.Tick();
			}
			catch (Exception e7)
			{
				WarnThrottled("Live wounds tick", e7);
			}
			GoreProf.End(31, t);
			if (ModOptions.TestButtons.Value && Time.time >= nextCensusAt)
			{
				nextCensusAt = Time.time + 20f;
				try
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)("[gore] " + GoreSkeleton.Census() + "; " + Splats.Census() + ", " + Stains.Census() + ", " + $"drops {Drops.Count} (peak {Drops.Peak}), sparks {Sparks.Count} (peak {Sparks.Peak}); " + GoreWounds.Census()));
					ScorchedVoxelsPlugin.Log.LogInfo((object)GoreProf.TopLine());
				}
				catch (Exception arg)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)$"Gore census failed: {arg}");
				}
			}
		}

		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 (float.IsFinite(v.x) && float.IsFinite(v.y))
			{
				return float.IsFinite(v.z);
			}
			return false;
		}

		internal static void WarnThrottled(string site, Exception e)
		{
			float unscaledTime = Time.unscaledTime;
			if (!warnNextAt.TryGetValue(site, out var value) || !(unscaledTime < value))
			{
				warnNextAt[site] = unscaledTime + 5f;
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"{site} failed: {e}");
			}
		}

		private static void OnCharacterDeathServer(DamageReport report)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (NetworkServer.active && Active && !((Object)(object)report?.victimBody == (Object)null))
				{
					Blow blow = Classify(report);
					NetworkInstanceId netId = ((NetworkBehaviour)report.victimBody).netId;
					GoreDebug.ApplyForcedKill(((NetworkInstanceId)(ref netId)).Value, ref blow);
					netId = ((NetworkBehaviour)report.victimBody).netId;
					NetMessageExtensions.Send((INetMessage)(object)new GoreDeathMessage(((NetworkInstanceId)(ref netId)).Value, blow), (NetworkDestination)1);
					HandleDeath(report.victimBody, blow);
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreSystem death hook failed: {arg}");
			}
		}

		internal static void OnDeathFromNet(uint netId, Blow blow)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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)
			try
			{
				GameObject val = ClientScene.FindLocalObject(new NetworkInstanceId(netId));
				CharacterBody val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<CharacterBody>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					HandleDeath(val2, blow);
				}
				else if (blow.pos != Vector3.zero && Active && VoxelTerrainManager.LocalConversionDone)
				{
					DeathSplash(blow.pos, blow.force, SplashPalette(blow.element, 0), 1f);
					ElementDeathBurst(blow.pos, blow.element, 1f, blow.oiled);
				}
			}
			catch (Exception arg)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"GoreSystem net death failed: {arg}");
			}
		}

		private static void HandleDeath(CharacterBody body, Blow blow)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0031: 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_005d: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (!Active || !NetworkClient.active || !VoxelTerrainManager.LocalConversionDone)
			{
				return;
			}
			int palette = PaletteForBody(body);
			Vector3 pos = ((blow.pos != Vector3.zero) ? blow.pos : body.corePosition);
			float num = Mathf.Max(body.radius, 0.5f);
			int num2 = SplashPalette(blow.element, palette);
			DeathSplash(pos, blow.force, num2, num);
			if (blow.kind == 2)
			{
				Vector3 val = GoreSkeleton.SlabNormal(blow.slabRot, blow.slabHalf);
				Vector3 swing = blow.force - val * Vector3.Dot(blow.force, val);
				if (((Vector3)(ref swing)).sqrMagnitude < 1f)
				{
					swing = GoreSkeleton.LongSlabAxis(blow.slabRot, blow.slabHalf);
				}
				SwingSplatter(pos, swing, val, num2, num, OverkillBoost(blow.overkill));
			}
			ElementDeathBurst(pos, blow.element, num, blow.oiled);
			OverkillSmear(pos, blow.force, SmearPalette(blow.element, num2), (float)blow.overkill / 64f);
			GoreSkeleton.OnDeath(body, blow, palette);
		}

		private static Blow Classify(DamageReport report)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0046: 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_00a0: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_0130: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Invalid comparison between Unknown and I4
			DamageInfo damageInfo = report.damageInfo;
			float fixedTime = Time.fixedTime;
			Vector3 pos = ((damageInfo != null && damageInfo.position != Vector3.zero) ? damageInfo.position : report.victimBody.corePosition);
			Vector3 force = damageInfo?.force ?? Vector3.zero;
			float num = (((Object)(object)report.victimBody.healthComponent != (Object)null) ? Mathf.Max(report.victimBody.healthComponent.fullCombinedHealth, 1f) : Mathf.Max(report.victimBody.maxHealth, 1f));
			bool oiled;
			Blow result = new Blow
			{
				kind = 3,
				pos = pos,
				force = force,
				overkill = (uint)Mathf.Clamp(report.damageDealt / num * 64f, 0f, 1024f),
				element = ElementOf(report, out oiled),
				oiled = oiled
			};
			if (damageInfo != null && TryRecentSlab(damageInfo.attacker, pos, fixedTime, out var best))
			{
				result.kind = 2;
				result.slabPos = best.pos;
				result.slabRot = best.rot;
				result.slabHalf = best.half;
				return result;
			}
			if (TryRecentBlast(pos, fixedTime, out var best2))
			{
				result.kind = 1;
				result.radius = Mathf.Clamp(best2.radius * 0.5f, 0.8f, 4.5f);
				return result;
			}
			if (damageInfo != null && DamageTypeCombo.op_Implicit(damageInfo.damageType & DamageTypeCombo.op_Implicit((DamageType)131072)) != 0L)
			{
				result.kind = 1;
				result.radius = 1.6f;
				return result;
			}
			if (damageInfo == null || (int)report.dotType != -1)
			{
				result.kind = 0;
			}
			return result;
		}

		private static int SmearPalette(byte elem, int splashPalette)
		{
			if ((splashPalette & -17) == 11)
			{
				return splashPalette;
			}
			switch (elem)
			{
			case 1:
			case 2:
			case 6:
				return 10;
			case 3:
				return 7;
			case 4:
				return 8;
			case 9:
				return 1;
			case 7:
				return 6;
			case 8:
				return 3;
			default:
				return splashPalette;
			}
		}

		private static int SplashPalette(byte elem, int palette)
		{
			if (elem != 5)
			{
				return palette;
			}
			return 9 | (palette & 0x10);
		}

		private static byte ElementOf(DamageReport report, out bool oiled)
		{
			//IL_0058: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//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_0196: 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_00e5: 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_01a3: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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_0125: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody victimBody = report.victimBody;
			oiled = false;
			try
			{
				oiled = victimBody.HasBuff(Buffs.Oiled);
			}
			catch
			{
			}
			try
			{
				HealthComponent healthComponent = victimBody.healthComponent;
				if ((Object)(object)healthComponent != (Object)null && healthComponent.isInFrozenState)
				{
					return 5;
				}
				if (victimBody.HasBuff(Buffs.Brittle))
				{
					return 5;
				}
			}
			catch
			{
			}
			byte b = ElemForDot(report.dotType);
			if (b != 0)
			{
				return b;
			}
			DamageInfo damageInfo = report.damageInfo;
			if (damageInfo != null)
			{
				DamageTypeCombo damageType = damageInfo.damageType;
				if (DamageTypeCombo.op_Implicit(damageType & DamageTypeCombo.op_Implicit((DamageType)8320)) != 0L)
				{
					return 1;
				}
				if (DamageTypeCombo.op_Implicit(damageType & DamageTypeCombo.op_Implicit((DamageType)4096)) != 0L)
				{
					return 3;
				}
				if (DamageTypeCombo.op_Implicit(damageType & DamageTypeCombo.op_Implicit((DamageType)1048576)) != 0L)
				{
					return 4;
				}
				if (DamageTypeCombo.op_Implicit(damageType & DamageTypeCombo.op_Implicit((DamageType)256)) != 0L)
				{
					return 5;
				}
				if (DamageTypeCombo.op_Implicit(damageType & DamageTypeCombo.op_Implicit((DamageType)98304)) != 0L)
				{
					return 7;
				}
				if (DamageTypeCombo.op_Implicit(damageType & DamageTypeCombo.op_Implicit((DamageType)1073741824)) != 0L)
				{
					return 8;
				}
				if (DamageTypeCombo.op_Implicit(damageType & DamageTypeCombo.op_Implicit((DamageType)16777216)) != 0L)
				{
					return 6;
				}
				DamageTypeExtended damageTypeExtended = damageType.damageTypeExtended;
				if ((ulong)(damageTypeExtended & 0x2200) != 0L)
				{
					return 6;
				}
				if ((ulong)(damageTypeExtended & 0x20000) != 0L)
				{
					return 5;
				}
				if ((ulong)(damageTypeExtended & 0x4008080) != 0L)
				{
					return 1;
				}
				if ((ulong)(damageTypeExtended & 4) != 0L)
				{
					return 9;
				}
			}
			try
			{
				DotController val = DotController.FindDotController(((Component)victimBody).gameObject);
				if ((Object)(object)val != (Object)null)
				{
					DotIndex[] dotPriority = DotPriority;
					foreach (DotIndex val2 in dotPriority)
					{
						if (val.HasDotActive(val2))
						{
							return ElemForDot(val2);
						}
					}
				}
			}
			catch
			{
			}
			return 0;
		}

		private static byte ElemForDot(DotIndex dot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected I4, but got Unknown
			switch (dot - 1)
			{
			case 0:
			case 2:
			case 6:
				return 1;
			case 1:
				return 2;
			case 3:
				return 3;
			case 4:
				return 4;
			case 7:
				return 7;
			case 8:
				return 8;
			case 9:
				return 5;
			case 10:
				return 6;
			default:
				return 0;
			}
		}

		internal static void RecordBlast(Vector3 pos, float radius)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			recentBlasts[recentBlastCursor] = new RecentBlast
			{
				pos = pos,
				radius = radius,
				time = Time.fixedTime
			};
			recentBlastCursor = (recentBlastCursor + 1) % recentBlasts.Length;
		}

		internal static void RecordSlab(GameObject attacker, Vector3 pos, Quaternion rot, Vector3 half)
		{
			//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_0024: 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_002c: 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)
			recentSlabs[recentSlabCursor] = new RecentSlab
			{
				attacker = attacker,
				pos = pos,
				rot = rot,
				half = half,
				time = Time.fixedTime
			};
			recentSlabCursor = (recentSlabCursor + 1) % recentSlabs.Length;
		}

		private static bool TryRecentBlast(Vector3 pos, float now, out RecentBlast best)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			best = default(RecentBlast);
			float num = -1f;
			RecentBlast[] array = recentBlasts;
			for (int i = 0; i < array.Length; i++)
			{
				RecentBlast recentBlast = array[i];
				if (!(recentBlast.radius <= 0f) && !(now - recentBlast.time > 0.3f))
				{
					float num2 = recentBlast.radius * 1.4f + 2f;
					Vector3 val = pos - recentBlast.pos;
					if (!(((Vector3)(ref val)).sqrMagnitude > num2 * num2) && recentBlast.radius > num)
					{
						num = recentBlast.radius;
						best = recentBlast;
					}
				}
			}
			return num > 0f;
		}

		private static bool TryRecentSlab(GameObject attacker, Vector3 pos, float now, out RecentSlab best)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			best = default(RecentSlab);
			bool flag = false;
			RecentSlab[] array = recentSlabs;
			for (int i = 0; i < array.Length; i++)
			{
				RecentSlab recentSlab = array[i];
				if (recentSlab.half == Vector3.zero || now - recentSlab.time > 0.45f)
				{
					continue;
				}
				bool flag2 = (Object)(object)attacker != (Object)null && (Object)(object)recentSlab.attacker == (Object)(object)attacker;
				Vector3 val = pos - recentSlab.pos;
				bool flag3 = ((Vector3)(ref val)).sqrMagnitude < 36f;
				if (flag2 || flag3)
				{
					if (!flag || flag2)
					{
						best = recentSlab;
						flag = true;
					}
					if (flag2)
					{
						break;
					}
				}
			}
			return flag;
		}

		public static void OnWorldCarve(Vector3 pos, float r)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!Active)
			{
				return;
			}
			try
			{
				Splats.EraseSphere(pos, r * 0.9f);
				Stains.EraseSphere(pos, r * 0.9f);
				GoreSkeleton.OnBlast(pos, r);
				GoreSkeleton.OnBlastWave(pos, r);
			}
			catch (Exception e)
			{
				WarnThrottled("GoreSystem world carve", e);
			}
		}

		public static void OnWorldGouge(Vector3 pos, Quaternion rot, Vector3 half)
		{
			//IL_0019: 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)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!Active)
			{
				return;
			}
			try
			{
				if (NetworkServer.active)
				{
					RecordSlab(null, pos, rot, half);
				}
				GoreSkeleton.OnGouge(pos, rot, half);
			}
			catch (Exception e)
			{
				WarnThrottled("GoreSystem world gouge", e);
			}
		}

		internal static void OnBulletHit(ref BulletHit hit)
		{
			if (Active)
			{
				long t = GoreProf.Begin();
				OnBulletHitInner(ref hit);
				GoreProf.End(43, t);
			}
		}

		private static void OnBulletHitInner(ref BulletHit hit)
		{
			//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_007e: 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_0049: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			Collider collider = hit.collider;
			if ((Object)(object)collider == (Object)null)
			{
				return;
			}
			if ((Object)(object)hit.hitHurtBox != (Object)null)
			{
				HealthComponent healthComponent = hit.hitHurtBox.healthComponent;
				if ((Object)(object)healthComponent != (Object)null && healthComponent.alive)
				{
					GoreWounds.OnHit(hit.hitHurtBox, healthComponent, hit.point, hit.direction, hit.surfaceNormal, 0);
					return;
				}
			}
			if (!GoreSkeleton.IsCorpseCollider(collider))
			{
				return;
			}
			Vector3 direction = hit.direction;
			if (NetworkServer.active)
			{
				ApplyBulletBite(hit.point, direction);
				if (RelayBulletHit())
				{
					NetMessageExtensions.Send((INetMessage)(object)new GoreHitMessage(hit.point, direction, request: false), (NetworkDestination)1);
				}
			}
			else if (NetworkClient.active)
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (!(realtimeSinceStartup - lastHitRequest < 0.02f))
				{
					lastHitRequest = realtimeSinceStartup;
					NetMessageExtensions.Send((INetMessage)(object)new GoreHitMessage(hit.point, direction, request: true), (NetworkDestination)2);
				}
			}
		}

		internal static bool RelayBulletHit()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup - lastHitRelay < 0.02f)
			{
				return false;
			}
			lastHitRelay = realtimeSinceStartup;
			return true;
		}

		internal static void ApplyBulletBite(Vector3 pos, Vector3 dir)
		{
			//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)
			if (!Active)
			{
				return;
			}
			try
			{
				GoreSkeleton.OnBullet(pos, dir);
			}
			catch (Exception e)
			{
				WarnThrottled("GoreSystem bullet bite", e);
			}
		}

		internal static void ServerWound(HurtBox hb, HealthComponent hc, Vector3 pos, Vector3 dir, byte flavor)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active && Active)
			{
				long t = GoreProf.Begin();
				ServerWoundInner(hb, hc, pos, dir, flavor);
				GoreProf.End(43, t);
			}
		}

		private static void ServerWoundInner(HurtBox hb, HealthComponent hc, Vector3 pos, Vector3 dir, byte flavor)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (!GoreWounds.OnHit(hb, hc, pos, dir, Vector3.zero, flavor))
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup - lastWoundRelay < 0.02f)
			{
				return;
			}
			lastWoundRelay = realtimeSinceStartup;
			CharacterBody body = hc.body;
			if (!((Object)(object)body == (Object)null))
			{
				NetworkInstanceId netId = ((NetworkBehaviour)body).netId;
				if (((NetworkInstanceId)(ref netId)).Value != 0)
				{
					netId = ((NetworkBehaviour)body).netId;
					NetMessageExtensions.Send((INetMessage)(object)new GoreWoundMessage(((NetworkInstanceId)(ref netId)).Value, pos, dir, flavor), (NetworkDestination)1);
				}
			}
		}

		internal static HurtBox ClosestHurtBox(CharacterBody body, Vector3 pos)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			HurtBoxGroup hurtBoxGroup = body.hurtBoxGroup;
			if ((Object)(object)hurtBoxGroup == (Object)null || hurtBoxGroup.hurtBoxes == null)
			{
				return body.mainHurtBox;
			}
			HurtBox val = null;
			float num = float.MaxValue;
			HurtBox[] hurtBoxes = hurtBoxGroup.hurtBoxes;
			foreach (HurtBox val2 in hurtBoxes)
			{
				if (!((Object)(object)val2 == (Object)null) && ((Behaviour)val2).isActiveAndEnabled)
				{
					Vector3 val3 = ((Component)val2).transform.position - pos;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						val = val2;
					}
				}
			}
			if (!((Object)(object)val != (Object)null))
			{
				return body.mainHurtBox;
			}
			return val;
		}

		private static void OnServerDamageDealtServer(DamageReport report)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: 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_016f: 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_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_0196: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			long t = GoreProf.Begin();
			try
			{
				if (!NetworkServer.active || !Active || report == null || (Object)(object)report.victimBody == (Object)null || (Object)(object)report.victim == (Object)null || !report.victim.alive)
				{
					return;
				}
				DamageInfo damageInfo = report.damageInfo;
				if (damageInfo == null || (int)report.dotType != -1)
				{
					return;
				}
				float num = Mathf.Max(report.victim.fullCombinedHealth, 1f);
				float num2 = report.damageDealt / num;
				if (num2 < 0.01f)
				{
					return;
				}
				CharacterBody attackerBody = report.attackerBody;
				bool flag = (((Object)(object)attackerBody != (Object)null && attackerBody.damage > 0.5f) ? (damageInfo.damage / attackerBody.damage) : 0f) >= 2.5f || num2 >= 0.25f;
				if (rng.NextDouble() >= (flag ? 0.1 : 0.02))
				{
					return;
				}
				CharacterBody victimBody = report.victimBody;
				if (victimBody.isPlayerControlled)
				{
					return;
				}
				CharacterMaster master = victimBody.master;
				if ((Object)(object)master != (Object)null && (Object)(object)master.playerCharacterMasterController != (Object)null)
				{
					return;
				}
				Vector3 pos = ((damageInfo.position != Vector3.zero) ? damageInfo.position : victimBody.corePosition);
				if (GoreSkeleton.LiveBite(victimBody, pos, damageInfo.force, num2))
				{
					NetworkInstanceId netId = ((NetworkBehaviour)victimBody).netId;
					if (((NetworkInstanceId)(ref netId)).Value != 0)
					{
						netId = ((NetworkBehaviour)victimBody).netId;
						NetMessageExtensions.Send((INetMessage)(object)new GoreLiveBiteMessage(((NetworkInstanceId)(ref netId)).Value, pos, damageInfo.force, num2), (NetworkDestination)1);
					}
				}
			}
			catch (Exception e)
			{
				WarnThrottled("live bite classify", e);
			}
			finally
			{
				GoreProf.End(43, t);
			}
		}

		internal static void WriteDebugPalettes(BinaryWriter w)
		{
			w.Write(Palettes.Length);
			for (int i = 0; i < Palettes.Length; i++)
			{
				w.Write(i);
				w.Write(Palettes[i].color.r);
				w.Write(Palettes[i].color.g);
				w.Write(Palettes[i].color.b);
				w.Write(Palettes[i].color.a);
				w.Write(Palettes[i].matte);
			}
		}

		internal static IEnumerable<KeyValuePair<string, Material>> DebugMaterials()
		{
			foreach (KeyValuePair<int, Material> item in Splats.DebugMaterials())
			{
				yield return new KeyValuePair<string, Material>("blood" + item.Key, item.Value);
			}
			foreach (KeyValuePair<int, Material> item2 in Stains.DebugFleshMaterials())
			{
				yield return new KeyValuePair<string, Material>("flesh" + item2.Key, item2.Value);
			}
			foreach (KeyValuePair<int, Material> item3 in Stains.DebugBoneMaterials())
			{
				yield return new KeyValuePair<string, Material>("bone" + item3.Key, item3.Value);
			}
		}

		private static int BloodCount(int baseCount)
		{
			return Mathf.Max(1, Mathf.RoundToInt((float)baseCount * BloodScale));
		}

		internal static void CutSpray(Vector3 pos, Vector3 dir, int palette, float size)
		{
			//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_0032: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				Splats.Burst(pos, dir, BloodCount(18), 3f + size, 0.12f * size, 0.4f * size, palette, 55f);
				Sparks.Emit(palette, pos, 6);
			}
		}

		internal static void BulletSpray(Vector3 pos, Vector3 dir, int palette)
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				Splats.Burst(pos + dir * 0.15f, dir, BloodCount(10), 2.4f, 0.09f, 0.24f, palette, 20f);
			}
		}

		internal static void SplatFromGib(Vector3 point, Vector3 normal, int palette, float speed)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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)
			if (Active)
			{
				float num = Mathf.Clamp(0.35f + speed * 0.05f, 0.4f, 1.1f);
				Splats.Add(point, normal, num * (0.8f + (float)rng.NextDouble() * 0.4f), palette);
				StainVoxels(point, num, palette);
				Sparks.Emit(palette, point, 3);
				if (speed > 6f)
				{
					int count = BloodCount(Mathf.Clamp((int)(speed * 0.5f), 3, 8));
					Splats.Burst(point + normal * 0.05f, normal, count, 2f, 0.08f, 0.24f, palette, 65f);
				}
			}
		}

		internal static void Dribble(Vector3 pos, int palette, bool sparkle = true)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			long t = GoreProf.Begin();
			DribbleInner(pos, palette, sparkle);
			GoreProf.End(25, t);
		}

		private static void DribbleInner(Vector3 pos, int palette, bool sparkle)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				Drops.EmitDrip(pos, palette);
				if (sparkle)
				{
					Sparks.Emit(palette, pos, 1);
				}
			}
		}

		internal static void SinewSnap(Vector3 from, Transform pieceTf, float pieceR, int palette)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			if (Active && !((Object)(object)pieceTf == (Object)null))
			{
				int num = ((pieceR > 1.1f) ? 3 : 2);
				for (int i = 0; i < num; i++)
				{
					Vector3 endLocal = RandomInSphere() * Mathf.Min(pieceR * 0.3f, 0.5f);
					Drops.EmitStrand(from + RandomInSphere() * 0.08f, pieceTf, endLocal, palette, 0.035f + (float)rng.NextDouble() * 0.03f);
				}
			}
		}

		internal static void SmokePuffs(Vector3 pos, int count)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				long t = GoreProf.Begin();
				Drops.EmitPuff(pos, count);
				GoreProf.End(24, t);
			}
		}

		internal static void VoidImplosion(Vector3 center, float radius, int count)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				long t = GoreProf.Begin();
				Sparks.EmitImplosion(center, count, radius);
				GoreProf.End(23, t);
			}
		}

		internal static void ElementDeathBurst(Vector3 pos, byte elem, float r, bool oiled)
		{
			//IL_006a: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_010f: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_0171: 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_0016: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			if (Active && VoxelTerrainManager.LocalConversionDone)
			{
				if (oiled && elem != 5)
				{
					Splats.Burst(pos, Vector3.down, BloodCount(8), 3f, 0.25f, 0.6f, 1, 75f);
				}
				switch (elem)
				{
				case 1:
					ElementMotes(elem, pos, oiled ? 40 : 22);
					StainVoxels(pos, r * 1.25f, 10);
					break;
				case 2:
					ElementMotes(elem, pos, 30);
					StainVoxels(pos, r * 1.25f, 10);
					break;
				case 3:
					ElementMotes(elem, pos, 26);
					Splats.Burst(pos, Vector3.down, BloodCount(8), 2.5f, 0.25f, 0.6f, 7, 70f);
					StainVoxels(pos, r * 1.2f, 7);
					break;
				case 4:
					ElementMotes(elem, pos, 26);
					Splats.Burst(pos, Vector3.down, BloodCount(8), 2.5f, 0.25f, 0.6f, 8, 70f);
					StainVoxels(pos, r * 1.2f, 8);
					break;
				case 5:
					ElementMotes(elem, pos, 34);
					StainVoxels(pos, r * 1.15f, 9);
					break;
				case 6:
					ElementMotes(elem, pos, 28);
					StainVoxels(pos, r * 0.9f, 10);
					ScorchStar(pos, r);
					break;
				case 7:
					ElementMotes(elem, pos, 10);
					Sparks.EmitImplosion(pos, 16, r * 1.4f);
					break;
				case 8:
					ElementMotes(elem, pos, 18);
					break;
				case 9:
					ElementMotes(elem, pos, 24);
					break;
				}
			}
		}

		internal static void ElementSizzle(byte elem, Vector3 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			long t = GoreProf.Begin();
			ElementSizzleInner(elem, pos);
			GoreProf.End(21, t);
		}

		private static void ElementSizzleInner(byte elem, Vector3 pos)
		{
			//IL_001b: 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)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				switch (elem)
				{
				case 3:
					Sparks.EmitStyle(in Sparks.AcidBubble, pos, 10);
					Splats.Burst(pos, Vector3.down, BloodCount(4), 2f, 0.14f, 0.4f, 7, 80f);
					break;
				case 4:
					Sparks.EmitStyle(in Sparks.BlightBubble, pos, 10);
					Splats.Burst(pos, Vector3.down, BloodCount(4), 2f, 0.14f, 0.4f, 8, 80f);
					break;
				case 9:
					Sparks.EmitStyle(in Sparks.NanoMote, pos, 10);
					Sparks.EmitStyle(in Sparks.ArcSpark, pos, 3);
					break;
				}
			}
		}

		internal static void ElementMotes(byte elem, Vector3 pos, int count)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			long t = GoreProf.Begin();
			ElementMotesInner(elem, pos, count);
			GoreProf.End(19, t);
		}

		private static void ElementMotesInner(byte elem, Vector3 pos, int count)
		{
			//IL_003a: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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)
			if (Active)
			{
				switch (elem)
				{
				case 1:
					Sparks.EmitStyle(in Sparks.Ember, pos, count);
					break;
				case 2:
					Sparks.EmitStyle(in Sparks.HelfireEmber, pos, count);
					break;
				case 3:
					Sparks.EmitStyle(in Sparks.AcidBubble, pos, count);
					break;
				case 4:
					Sparks.EmitStyle(in Sparks.BlightBubble, pos, count);
					break;
				case 5:
					Sparks.EmitStyle(in Sparks.FrostGlint, pos, count);
					break;
				case 6:
					Sparks.EmitStyle(in Sparks.ArcSpark, pos, count);
					break;
				case 7:
					Sparks.EmitStyle(in Sparks.VoidMote, pos, count);
					break;
				case 8:
					Sparks.EmitStyle(in Sparks.LunarMote, pos, count);
					break;
				case 9:
					Sparks.EmitStyle(in Sparks.NanoMote, pos, count);
					break;
				}
			}
		}

		internal static void ArcFlash(Vector3 a, Vector3 b)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				long t = GoreProf.Begin();
				Sparks.EmitArc(a, b);
				GoreProf.End(20, t);
			}
		}

		internal static void SwingSplatter(Vector3 pos, Vector3 swing, Vector3 planeNormal, int palette, float size, float boost = 1f)
		{
			//IL_0016: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_0104: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			if (!Active)
			{
				return;
			}
			if (((Vector3)(ref swing)).sqrMagnitude < 0.01f)
			{
				swing = RandomHorizontal();
			}
			((Vector3)(ref swing)).Normalize();
			size = Mathf.Clamp(size, 0.6f, 3f);
			int count = BloodCount(Mathf.RoundToInt((7f + 4f * size) * boost));
			for (int i = -1; i <= 1; i++)
			{
				Vector3 val = Quaternion.AngleAxis((float)i * 26f, planeNormal) * swing;
				Splats.Burst(pos, val, count, 5.5f + 2f * size, 0.18f * size, 0.5f * size, palette, 14f);
				Vector3 val2 = val + RandomInSphere() * 0.12f;
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				if (BloodRayBudgeted(pos, normalized, 9f, out var hit))
				{
					Splats.Add(((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, (0.6f + (float)rng.NextDouble() * 0.5f) * size, palette);
				}
			}
			Sparks.Emit(palette, pos, 4);
		}

		internal static void OverkillSmear(Vector3 pos, Vector3 force, int palette, float ratio)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0041: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: 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_00dd: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			if (!Active || ratio < 1.5f || !VoxelTerrainManager.LocalConversionDone)
			{
				return;
			}
			Vector3 val = force;
			val.y = 0f;
			val = ((((Vector3)(ref val)).sqrMagnitude > 0.5f) ? ((Vector3)(ref val)).normalized : RandomHorizontal());
			float num = Mathf.Min(4f + ratio * 2f, 14f);
			int num2 = BloodCount(Mathf.Clamp(Mathf.RoundToInt(5f + ratio * 2.5f), 6, 16));
			for (int i = 0; i < num2; i++)
			{
				float num3 = ((float)i + 0.35f + (float)rng.NextDouble() * 0.5f) / (float)num2;
				Vector3 origin = pos + val * (num3 * num) + RandomInSphere() * 0.55f;
				origin.y = pos.y + 0.8f;
				if (BloodRayBudgeted(origin, Vector3.down, 4.5f, out var hit))
				{
					Splats.Add(((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, Mathf.Lerp(1.15f, 0.35f, num3) * (0.8f + (float)rng.NextDouble() * 0.4f), palette);
				}
			}
			if (BloodRayBudgeted(pos + val * num + Vector3.up * 0.8f, Vector3.down, 5.5f, out var hit2))
			{
				Splats.AddGrowing(((RaycastHit)(ref hit2)).point, ((RaycastHit)(ref hit2)).normal, 1.1f, 2.2f, 5f, palette);
				StainVoxels(((RaycastHit)(ref hit2)).point, 1.7f, palette);
			}
		}

		private static void ScorchStar(Vector3 pos, float r)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			int num = 4 + rng.Next(2);
			float num2 = (float)(rng.NextDouble() * Math.PI * 2.0);
			Vector3 val = default(Vector3);
			for (int i = 0; i < num; i++)
			{
				double num3 = (double)num2 + (double)i * (Math.PI * 2.0 / (double)num) + (rng.NextDouble() - 0.5) * 0.5;
				((Vector3)(ref val))..ctor((float)Math.Cos(num3), 0f, (float)Math.Sin(num3));
				for (int j = 0; j < 3; j++)
				{
					float num4 = ((float)j + 0.6f + (float)rng.NextDouble() * 0.4f) / 3f;
					if (BloodRayBudgeted(pos + val * (num4 * (r * 1.5f + 1.2f)) + Vector3.up * 0.8f, Vector3.down, 4f, out var hit))
					{
						Splats.Add(((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, Mathf.Lerp(0.55f, 0.18f, num4) * Mathf.Max(r, 0.8f), 10);
					}
				}
			}
		}

		internal static void ElementPool(byte elem, Vector3 pos, float radius)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				int num;
				switch (elem)
				{
				default:
					num = -1;
					break;
				case 1:
				case 2:
					num = 10;
					break;
				case 4:
					num = 8;
					break;
				case 3:
					num = 7;
					break;
				}
				int num2 = num;
				if (num2 >= 0)
				{
					long t = GoreProf.Begin();
					StainVoxels(pos, radius, num2);
					GoreProf.End(22, t);
				}
			}
		}

		internal static Material BoneMaterial(int palette)
		{
			return Stains.BoneMaterial(palette);
		}

		internal static Material FleshMaterial(int palette)
		{
			return Stains.FleshMaterial(palette);
		}

		private static void DeathSplash(Vector3 pos, Vector3 force, int palette, float bodyRadius)
		{
			//IL_0012: 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)
			//IL_001b: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_014a: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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_00b3: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00de: 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_00ff: 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)
			float num = Mathf.Clamp(bodyRadius, 0.6f, 4f);
			Sparks.Emit(palette, pos, 12);
			if (BloodRayBudgeted(pos + Vector3.up * 0.6f, Vector3.down, 3f + num, out var hit))
			{
				Splats.AddGrowing(((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, (0.75f + (float)rng.NextDouble() * 0.3f) * num, (1.35f + (float)rng.NextDouble() * 0.7f) * num, 4.5f, palette);
				StainVoxels(((RaycastHit)(ref hit)).point, num * 1.55f, palette);
				int i = 0;
				for (int num2 = BloodCount(10); i < num2; i++)
				{
					Vector3 val = RandomInSphere();
					val.y = 0f;
					if (BloodRayBudgeted(pos + Vector3.up * 0.6f + val * num, Vector3.down, 3f + num, out var hit2))
					{
						Splats.Add(((RaycastHit)(ref hit2)).point, ((RaycastHit)(ref hit2)).normal, (0.42f + (float)rng.NextDouble() * 0.5f) * num, palette);
					}
				}
			}
			Vector3 dir = ((((Vector3)(ref force)).sqrMagnitude > 1f) ? ((Vector3)(ref force)).normalized : RandomHorizontal());
			Splats.Burst(pos, dir, BloodCount(24), 3.5f + num * 1.5f, 0.14f * num, 0.36f * num, palette, 36f);
		}

		private static void StainVoxels(Vector3 pos, float radius, int palette)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Active && VoxelTerrainManager.VolumesForStains != null && stainQueue.Count < 24 && !StainCovered(pos, radius, palette))
			{
				stainQueue.Enqueue(new StainReq
				{
					pos = pos,
					radius = radius,
					palette = palette
				});
			}
		}

		private static bool StainCovered(Vector3 pos, float radius, int palette)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			Vector3 val;
			for (int num = recentStains.Count - 1; num >= 0; num--)
			{
				RecentStain recentStain = recentStains[num];
				if (time >= recentStain.until)
				{
					recentStains.RemoveAt(num);
				}
				else if (recentStain.palette == palette && recentStain.radius >= radius * 0.8f)
				{
					val = recentStain.pos - pos;
					if (((Vector3)(ref val)).sqrMagnitude < recentStain.radius * recentStain.radius * 0.16f)
					{
						return true;
					}
				}
			}
			StainJob stainJob = activeStain;
			if (stainJob != null && stainJob.palette == palette && stainJob.radius >= radius * 0.8f)
			{
				val = stainJob.pos - pos;
				if (((Vector3)(ref val)).sqrMagnitude < stainJob.radius * stainJob.radius * 0.16f)
				{
					return true;
				}
			}
			foreach (StainReq item in stainQueue)
			{
				if (item.palette == palette && item.radius >= radius * 0.8f)
				{
					val = item.pos - pos;
					if (((Vector3)(ref val)).sqrMagnitude < item.radius * item.radius * 0.16f)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static void DrainStainQueue()
		{
			if (activeStain == null && stainQueue.Count == 0)
			{
				return;
			}
			long num = Stopwatch.GetTimestamp() + (long)(0.0025 * (double)Stopwatch.Frequency);
			bool flag = false;
			while (true)
			{
				if (activeStain == null)
				{
					if (stainQueue.Count == 0)
					{
						break;
					}
					activeStain = BeginStain(stainQueue.Dequeue());
					if (activeStain == null)
					{
						continue;
					}
				}
				if (flag && Stopwatch.GetTimestamp() >= num)
				{
					break;
				}
				flag = true;
				if (!StepStain(activeStain))
				{
					FinishStain(activeStain);
					activeStain = null;
				}
			}
		}

		private static StainJob BeginStain(StainReq req)
		{
			//IL_0018: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: 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_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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)
			List<VoxelVolume> volumesForStains = VoxelTerrainManager.VolumesForStains;
			if (volumesForStains == null)
			{
				return null;
			}
			StainJob stainJob = new StainJob
			{
				pos = req.pos,
				radius = req.radius,
				palette = req.palette
			};
			try
			{
				foreach (VoxelVolume item in volumesForStains)
				{
					if (item == null || item.chunks == null || ((Bounds)(ref item.meshBoundsWS)).SqrDistance(req.pos) > req.radius * req.radius)
					{
						continue;
					}
					float num = 16f * item.voxelSize;
					int num2 = Mathf.FloorToInt((req.pos.x - req.radius) / num);
					int num3 = Mathf.FloorToInt((req.pos.x + req.radius) / num);
					int num4 = Mathf.FloorToInt((req.pos.y - req.radius) / num);
					int num5 = Mathf.FloorToInt((req.pos.y + req.radius) / num);
					int num6 = Mathf.FloorToInt((req.pos.z - req.radius) / num);
					int num7 = Mathf.FloorToInt((req.pos.z + req.radius) / num);
					for (int i = num2; i <= num3; i++)
					{
						for (int j = num4; j <= num5; j++)
						{
							for (int k = num6; k <= num7; k++)
							{
								long num8 = VoxelVolume.PackKey(i, j, k);
								if (item.chunks.ContainsKey(num8))
								{
									stainJob.chunks.Add((item, num8, new Vector3((float)i, (float)j, (float)k) * num));
								}
							}
						}
					}
				}
			}
			catch (Exception)
			{
				return null;
			}
			if (stainJob.chunks.Count == 0)
			{
				return null;
			}
			Vector3 p = req.pos;
			stainJob.chunks.Sort(delegate((VoxelVolume vol, long key, Vector3 org) x, (VoxelVolume vol, long key, Vector3 org) y)
			{
				//IL_0025: 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_0037: 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_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_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				float num9 = 16f * x.vol.voxelSize;
				float num10 = 16f * y.vol.voxelSize;
				Vector3 val = x.org + new Vector3(num9, num9, num9) * 0.5f - p;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				val = y.org + new Vector3(num10, num10, num10) * 0.5f - p;
				return sqrMagnitude.CompareTo(((Vector3)(ref val)).sqrMagnitude);
			});
			if (stainJob.chunks.Count > 8)
			{
				stainJob.chunks.RemoveRange(8, stainJob.chunks.Count - 8);
			}
			patchV.Clear();
			patchN.Clear();
			patchT.Clear();
			recentStains.Add(new RecentStain
			{
				pos = req.pos,
				radius = req.radius,
				palette = req.palette,
				until = Time.time + 2.5f
			});
			if (recentStains.Count > 48)
			{
				recentStains.RemoveAt(0);
			}
			return stainJob;
		}

		private static bool StepStain(StainJob job)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			var (voxelVolume, key, org) = job.chunks[job.next++];
			try
			{
				if (voxelVolume != null && voxelVolume.chunks != null && voxelVolume.chunks.TryGetValue(key, out var value) && value.density != null)
				{
					VoxelTerrainManager.ChunkMeshData chunkMeshData = VoxelTerrainManager.BuildFineChunkData(voxelVolume, value, key, stainSp, stainSn, stainSi, pooled: false);
					if (chunkMeshData != null)
					{
						AppendStainTris(chunkMeshData, org, job.pos, job.radius);
					}
				}
			}
			catch (Exception)
			{
			}
			if (job.next < job.chunks.Count)
			{
				return patchT.Count < 1560;
			}
			return false;
		}

		private static void FinishStain(StainJob job)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (patchT.Count >= 3)
			{
				Stains.AddPatch(job.palette, patchV, patchN, patchT, job.pos, job.radius);
			}
		}

		private static void AppendStainTris(VoxelTerrainManager.ChunkMeshData data, Vector3 org, Vector3 pos, float radius)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			patchMap.Clear();
			float r = radius * radius;
			if (data.subIndices != null)
			{
				List<int>[] subIndices = data.subIndices;
				foreach (List<int> list in subIndices)
				{
					if (list != null)
					{
						AppendStainList(data, list, org, pos, r);
					}
				}
			}
			else if (data.indices != null)
			{
				AppendStainList(data, data.indices, org, pos, r);
			}
		}

		private static void AppendStainList(VoxelTerrainManager.ChunkMeshData data, List<int> tris, Vector3 org, Vector3 pos, float r2)
		{
			//IL_003c: 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_004d: 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_005e: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i + 2 < tris.Count; i += 3)
			{
				if (patchT.Count >= 1560)
				{
					break;
				}
				int num = tris[i];
				int num2 = tris[i + 1];
				int num3 = tris[i + 2];
				Vector3 val = (data.positions[num] + data.positions[num2] + data.positions[num3]) / 3f + org - pos;
				if (!(((Vector3)(ref val)).sqrMagnitude > r2))
				{
					patchT.Add(StainVert(data, num, org));
					patchT.Add(StainVert(data, num2, org));
					patchT.Add(StainVert(data, num3, org));
				}
			}
		}

		private static int StainVert(VoxelTerrainManager.ChunkMeshData data, int i, Vector3 org)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (patchMap.TryGetValue(i, out var value))
			{
				return value;
			}
			Vector3 val = ((data.normals != null && i < data.normals.Count) ? data.normals[i] : Vector3.up);
			value = patchV.Count;
			patchMap[i] = value;
			patchV.Add(data.positions[i] + org + val * (0.012f + (float)rng.NextDouble() * 0.01f));
			patchN.Add(val);
			return value;
		}

		private static bool BloodRay(Vector3 origin, Vector3 dir, float len, out RaycastHit hit)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			LayerIndex world = LayerIndex.world;
			return Physics.Raycast(origin, dir, ref hit, len, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1);
		}

		private static bool BloodRayBudgeted(Vector3 origin, Vector3 dir, float len, out RaycastHit hit)
		{
			//IL_0038: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			int frameCount = Time.frameCount;
			if (frameCount != burstRayFrame)
			{
				burstRayFrame = frameCount;
				burstRayBudget = 96;
			}
			if (burstRayBudget <= 0)
			{
				hit = default(RaycastHit);
				return false;
			}
			burstRayBudget--;
			return BloodRay(origin, dir, len, out hit);
		}

		private static Vector3 RandomInSphere()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			for (int i = 0; i < 8; i++)
			{
				((Vector3)(ref result))..ctor((float)rng.NextDouble() * 2f - 1f, (float)rng.NextDouble() * 2f - 1f, (float)rng.NextDouble() * 2f - 1f);
				if (((Vector3)(ref result)).sqrMagnitude <= 1f)
				{
					return result;
				}
			}
			return Vector3.up;
		}

		private static Vector3 RandomHorizontal()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			double num = rng.NextDouble() * Math.PI * 2.0;
			return new Vector3((float)Math.Cos(num), 0f, (float)Math.Sin(num));
		}

		private static float UploadThrottle(int verts)
		{
			if (verts >= 3000)
			{
				return Mathf.Min((float)verts / 18000f, 1f) * 0.12f;
			}
			return 0f;
		}

		private static Shader FindShaderSafe(params string[] names)
		{
			string[] array = names;
			foreach (string text in array)
			{
				try
				{
					Shader val = Shader.Find(text);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
				catch
				{
				}
			}
			Shader[] array2;
			try
			{
				array2 = Resources.FindObjectsOfTypeAll<Shader>();
			}
			catch
			{
				return null;
			}
			array = names;
			foreach (string text2 in array)
			{
				Shader[] array3 = array2;
				foreach (Shader val2 in array3)
				{
					if ((Object)(object)val2 != (Object)null && ((Object)val2).name.Trim() == text2)
					{
						return val2;
					}
				}
			}
			return null;
		}

		static GoreSystem()
		{
			DotIndex[] array = new DotIndex[10];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			DotPriority = (DotIndex[])(object)array;
			stainSp = new List<Vector3>();
			stainSn = new List<Vector3>();
			stainSi = new List<int>();
			patchV = new List<Vector3>();
			patchN = new List<Vector3>();
			patchT = new List<int>();
			patchMap = new Dictionary<int, int>();
			stainQueue = new Queue<StainReq>();
			recentStains = new List<RecentStain>(48);
			burstRayFrame = -1;
		}
	}
	internal static class GoreWounds
	{
		private class Wound
		{
			public GameObject go;

			public Transform tf;

			public CharacterBody body;

			public float dieAt;

			public float size;

			public Vector3 axes = Vector3.one;
		}

		private class Bleeder
		{
			public CharacterBody body;

			public Transform anchor;

			public Vector3 localPos;

			public int palette;

			public float until;

			public float next;
		}

		internal const byte FlavorNone = 0;

		internal const byte FlavorImpale = 1;

		internal const byte FlavorSpark = 2;

		internal const byte FlavorSip = 3;

		private const int MaxWounds = 96;

		private const int MaxPerBody = 12;

		private const float PerBodyGap = 0.18f;

		private const float WoundTTL = 18f;

		private const float WoundShrink = 1.2f;

		private const int MaxBleeders = 24;

		private const float BleedTime = 3.2f;

		private const float BleedStep = 0.5f;

		private static readonly List<Wound> wounds = new List<Wound>();

		private static readonly List<Bleeder> bleeders = new List<Bleeder>();

		private static readonly Dictionary<CharacterBody, float> lastWoundAt = new Dictionary<CharacterBody, float>();

		private static Mesh quad;

		private static Mesh shaft;

		private static float nextPruneAt;

		private static readonly Random rng = new Random(96777709);

		private static readonly List<CharacterBody> pruneScratch = new List<CharacterBody>();

		public static void Reset()
		{
			foreach (Wound wound in wounds)
			{
				if ((Object)(object)wound.go != (Object)null)
				{
					Object.Destroy((Object)(object)wound.go);
				}
			}
			wounds.Clear();
			bleeders.Clear();
			lastWoundAt.Clear();
		}

		public static bool OnHit(HurtBox hb, HealthComponent hc, Vector3 pos, Vector3 dir, Vector3 normal, byte flavor = 0)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00a4: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			if (!GoreSystem.Active || !VoxelTerrainManager.LocalConversionDone)
			{
				return false;
			}
			CharacterBody body = hc.body;
			if ((Object)(object)body == (Object)null || (Object)(object)hb == (Object)null)
			{
				return false;
			}
			float time = Time.time;
			if (lastWoundAt.TryGetValue(body, out var value) && time - value < 0.18f)
			{
				return false;
			}
			lastWoundAt[body] = time;
			if (lastWoundAt.Count > 96 && time >= nextPruneAt)
			{
				nextPruneAt = time + 5f;
				PruneStamps();
			}
			int palette = GoreSystem.PaletteForBody(body);
			GoreSystem.BulletSpray(pos, dir, palette);
			SpawnWound(((Component)hb).transform, body, pos, (((Vector3)(ref normal)).sqrMagnitude > 0.01f) ? normal : (-dir), palette);
			switch (flavor)
			{
			case 1:
				SpawnShaft(((Component)hb).transform, body, pos, dir, palette);
				break;
			case 2:
				GoreSystem.ElementMotes(6, pos, 4);
				break;
			case 3:
				GoreSystem.ElementMotes(3, pos, 3);
				break;
			}
			Bleeder bleeder = null;
			foreach (Bleeder bleeder2 in bleeders)
			{
				if ((Object)(object)bleeder2.body == (Object)(object)body)
				{
					bleeder = bleeder2;
					break;
				}
			}
			if (bleeder == null)
			{
				if (bleeders.Count >= 24)
				{
					bleeders.RemoveAt(0);
				}
				bleeder = new Bleeder
				{
					body = body
				};
				bleeders.Add(bleeder);
			}
			bleeder.anchor = ((Component)hb).transform;
			bleeder.localPos = ((Component)hb).transform.InverseTransformPoint(pos);
			bleeder.palette = palette;
			bleeder.until = time + 3.2f;
			bleeder.next = time + 0.25f;
			return true;
		}

		internal static string Census()
		{
			return $"wounds {wounds.Count}, bleeders {bleeders.Count}";
		}

		public static void Tick()
		{
			//IL_0077: 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_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)
			float time = Time.time;
			for (int num = wounds.Count - 1; num >= 0; num--)
			{
				Wound wound = wounds[num];
				if ((Object)(object)wound.go == (Object)null)
				{
					wounds.RemoveAt(num);
				}
				else
				{
					float num2 = wound.dieAt - time;
					if (num2 <= 0f)
					{
						Object.Destroy((Object)(object)wound.go);
						wounds.RemoveAt(num);
					}
					else if (num2 < 1.2f)
					{
						wound.tf.localScale = wound.axes * (wound.size * Mathf.Max(num2 / 1.2f, 0.05f));
					}
				}
			}
			for (int num3 = bleeders.Count - 1; num3 >= 0; num3--)
			{
				Bleeder bleeder = bleeders[num3];
				if ((Object)(object)bleeder.anchor == (Object)null || (Object)(object)bleeder.body == (Object)null || (Object)(object)bleeder.body.healthComponent == (Object)null || !bleeder.body.healthComponent.alive || time >= bleeder.until)
				{
					bleeders.RemoveAt(num3);
				}
				else if (!(time < bleeder.next))
				{
					bleeder.next = time + 0.5f;
					GoreSystem.Dribble(bleeder.anchor.TransformPoint(bleeder.localPos), bleeder.palette, sparkle: false);
				}
			}
		}

		public static void DropOn(Transform bone)
		{
			if ((Object)(object)bone == (Object)null)
			{
				return;
			}
			for (int num = wounds.Count - 1; num >= 0; num--)
			{
				Wound wound = wounds[num];
				if (!((Object)(object)wound.go == (Object)null) && !((Object)(object)wound.tf == (Object)null) && wound.tf.IsChildOf(bone))
				{
					Object.Destroy((Object)(object)wound.go);
					wounds.RemoveAt(num);
				}
			}
		}

		private static void SpawnWound(Transform anchor, CharacterBody body, Vector3 pos, Vector3 normal, int palette)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: 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_01cb: 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)
			Material val = GoreSystem.FleshMaterial(palette);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			int num = 0;
			Wound wound = null;
			foreach (Wound wound2 in wounds)
			{
				if (!((Object)(object)wound2.body != (Object)(object)body))
				{
					num++;
					if (wound == null || wound2.dieAt < wound.dieAt)
					{
						wound = wound2;
					}
				}
			}
			if (num >= 12 && wound != null)
			{
				if ((Object)(object)wound.go != (Object)null)
				{
					Object.Destroy((Object)(object)wound.go);
				}
				wounds.Remove(wound);
			}
			if (wounds.Count >= 96)
			{
				if ((Object)(object)wounds[0].go != (Object)null)
				{
					Object.Destroy((Object)(object)wounds[0].go);
				}
				wounds.RemoveAt(0);
			}
			GameObject val2 = new GameObject("gorewound");
			Transform transform = val2.transform;
			transform.SetParent(anchor, false);
			transform.position = pos + normal * 0.015f;
			transform.rotation = Quaternion.LookRotation(-normal) * Quaternion.Euler(0f, 0f, (float)rng.NextDouble() * 360f);
			float num2 = Mathf.Clamp(body.radius * 0.1f, 0.06f, 0.3f) * (0.75f + (float)rng.NextDouble() * 0.5f);
			Vector3 lossyScale = anchor.lossyScale;
			float num3 = Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Max(Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)));
			if (num3 > 0.001f)
			{
				num2 /= num3;
			}
			transform.localScale = Vector3.one * num2;
			val2.AddComponent<MeshFilter>().sharedMesh = SharedQuad();
			MeshRenderer obj = val2.AddComponent<MeshRenderer>();
			((Renderer)obj).sharedMaterial = val;
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			wounds.Add(new Wound
			{
				go = val2,
				tf = transform,
				body = body,
				dieAt = Time.time + 18f + (float)rng.NextDouble() * 4f,
				size = num2
			});
		}

		private static void SpawnShaft(Transform anchor, CharacterBody body, Vector3 pos, Vector3 dir, int palette)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0081: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			Material val = GoreSystem.BoneMaterial(palette);
			if ((Object)(object)val == (Object)null || ((Vector3)(ref dir)).sqrMagnitude < 0.01f)
			{
				return;
			}
			if (wounds.Count >= 96)
			{
				if ((Object)(object)wounds[0].go != (Object)null)
				{
					Object.Destroy((Object)(object)wounds[0].go);
				}
				wounds.RemoveAt(0);
			}
			GameObject val2 = new GameObject("goreshaft");
			Transform transform = val2.transform;
			transform.SetParent(anchor, false);
			transform.position = pos;
			transform.rotation = Quaternion.LookRotation(-((Vector3)(ref dir)).normalized) * Quaternion.Euler(0f, 0f, (float)rng.NextDouble() * 360f);
			float num = Mathf.Clamp(body.radius * 0.3f, 0.18f, 0.55f) * (0.85f + (float)rng.NextDouble() * 0.3f);
			Vector3 lossyScale = anchor.lossyScale;
			float num2 = Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Max(Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)));
			if (num2 > 0.001f)
			{
				num /= num2;
			}
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(0.16f, 0.16f, 1f);
			transform.localScale = val3 * num;
			val2.AddComponent<MeshFilter>().sharedMesh = SharedShaft();
			MeshRenderer obj = val2.AddComponent<MeshRenderer>();
			((Renderer)obj).sharedMaterial = val;
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			wounds.Add(new Wound
			{
				go = val2,
				tf = transform,
				body = body,
				dieAt = Time.time + 18f + (float)rng.NextDouble() * 4f,
				size = num,
				axes = val3
			});
		}

		private static Mesh SharedQuad()
		{
			//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_0028: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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)
			if ((Object)(object)quad != (Object)null)
			{
				return quad;
			}
			quad = new Mesh
			{
				name = "gorewound"
			};
			Vector3[] array = (Vector3[])(object)new Vector3[8];
			Vector3[] array2 = (Vector3[])(object)new Vector3[8];
			for (int i = 0; i < 8; i++)
			{
				float num = (float)i * (MathF.PI / 4f);
				float num2 = 0.5f * ((i % 2 == 0) ? 1f : 0.72f);
				array[i] = new Vector3(Mathf.Cos(num) * num2, Mathf.Sin(num) * num2, 0f);
				array2[i] = Vector3.back;
			}
			List<int> list = new List<int>();
			for (int j = 1; j < 7; j++)
			{
				list.Add(0);
				list.Add(j + 1);
				list.Add(j);
				list.Add(0);
				list.Add(j);
				list.Add(j + 1);
			}
			quad.vertices = array;
			quad.normals = array2;
			quad.SetTriangles(list, 0);
			quad.bounds = new Bounds(Vector3.zero, Vector3.one);
			return quad;
		}

		private static Mesh SharedShaft()
		{
			//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_0028: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0098: 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_00b3: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)shaft != (Object)null)
			{
				return shaft;
			}
			shaft = new Mesh
			{
				name = "goreshaft"
			};
			Vector3[] array = (Vector3[])(object)new Vector3[8];
			Vector3[] array2 = (Vector3[])(object)new Vector3[8];
			array[0] = new Vector3(-0.5f, 0f, 0f);
			array[1] = new Vector3(0.5f, 0f, 0f);
			array[2] = new Vector3(0.5f, 0f, 1f);
			array[3] = new Vector3(-0.5f, 0f, 1f);
			array[4] = new Vector3(0f, -0.5f, 0f);
			array[5] = new Vector3(0f, 0.5f, 0f);
			array[6] = new Vector3(0f, 0.5f, 1f);
			array[7] = new Vector3(0f, -0.5f, 1f);
			for (int i = 0; i < 4; i++)
			{
				array2[i] = Vector3.up;
			}
			for (int j = 4; j < 8; j++)
			{
				array2[j] = Vector3.right;
			}
			List<int> list = new List<int>
			{
				0, 1, 2, 0, 2, 3, 0, 2, 1, 0,
				3, 2, 4, 5, 6, 4, 6, 7, 4, 6,
				5, 4, 7, 6
			};
			shaft.vertices = array;
			shaft.normals = array2;
			shaft.SetTriangles(list, 0);
			shaft.bounds = new Bounds(new Vector3(0f, 0f, 0.5f), new Vector3(1f, 1f, 1f));
			return shaft;
		}

		private static void PruneStamps()
		{
			pruneScratch.Clear();
			foreach (KeyValuePair<CharacterBody, float> item in lastWoundAt)
			{
				if ((Object)(object)item.Key == (Object)null)
				{
					pruneScratch.Add(item.Key);
				}
			}
			foreach (CharacterBody item2 in pruneScratch)
			{
				lastWoundAt.Remove(item2);
			}
			pruneScratch.Clear();
		}
	}
	internal static class MapRules
	{
		private static readonly HashSet<string> VanillaScenes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, string[]> SkipByScene = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)
		{
			["lemuriantemple"] = new string[1] { "matLTGodrayBarrier" },
			["moon2"] = new string[2] { "MoonTempleIsland", "TempleBase" }
		};

		public static bool SkipEntireScene(string sceneName)
		{
			return VanillaScenes.Contains(sceneName);
		}

		public static bool ShouldSkip(string sceneName, string goName, string matName)
		{
			if (!SkipByScene.TryGetValue(sceneName, out var value))
			{
				return false;
			}
			string[] array = value;
			foreach (string value2 in array)
			{
				if (goName != null && goName.IndexOf(value2, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (matName != null && matName.IndexOf(value2, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class MaterialHardness
	{
		private struct Entry
		{
			public readonly string fragment;

			public readonly float multiplier;

			public Entry(string fragment, float multiplier)
			{
				this.fragment = fragment;
				this.multiplier = multiplier;
			}
		}

		private static readonly Entry[] Table = new Entry[25]
		{
			new Entry("metal", 0.45f),
			new Entry("iron", 0.45f),
			new Entry("pipe", 0.5f),
			new Entry("grate", 0.5f),
			new Entry("concrete", 0.55f),
			new Entry("crystal", 0.6f),
			new Entry("ice", 0.7f),
			new Entry("rock", 0.8f),
			new Entry("stone", 0.8f),
			new Entry("boulder", 0.8f),
			new Entry("cliff", 0.8f),
			new Entry("ruins", 0.8f),
			new Entry("temple", 0.8f),
			new Entry("column", 0.8f),
			new Entry("pillar", 0.8f),
			new Entry("brick", 0.8f),
			new Entry("statue", 0.8f),
			new Entry("root", 0.9f),
			new Entry("wood", 0.9f),
			new Entry("lava", 1.1f),
			new Entry("grass", 1.1f),
			new Entry("coral", 1.15f),
			new Entry("dirt", 1.2f),
			new Entry("sand", 1.25f),
			new Entry("snow", 1.35f)
		};

		public static float ScaleFor(Material mat, Material mat2)
		{
			string text = (((Object)(object)mat != (Object)null) ? ((Object)mat).name : null);
			string text2 = (((Object)(object)mat2 != (Object)null && (Object)(object)mat2 != (Object)(object)mat) ? ((Object)mat2).name : null);
			if (text == null && text2 == null)
			{
				return 1f;
			}
			Entry[] table = Table;
			for (int i = 0; i < table.Length; i++)
			{
				Entry entry = table[i];
				if (Contains(text, entry.fragment) || Contains(text2, entry.fragment))
				{
					return entry.multiplier;
				}
			}
			return 1f;
		}

		private static bool Contains(string haystack, string needle)
		{
			if (haystack != null)
			{
				return haystack.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}
	}
	internal static class MeshReadback
	{
		internal sealed class Data
		{
			public Vector3[] verts;

			public Vector2[] uv0;

			public Vector2[] uv2;

			public Color32[] colors;

			public int[][] subTris;

			public int[] SubTriangles(int s)
			{
				return subTris[s];
			}
		}

		private static readonly HashSet<string> Whitelist = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
		{
			"meshSnowyForestTerrainGround", "meshSnowyForestTerrainCaveCollison", "meshSnowyForestTerrainWall", "meshSnowyForestAqueduct", "meshSnowyForestAqueductTopLG", "meshSnowyForestAqueductTopSM", "meshSnowyForestGiantTrees", "mdlSnowyForestTreeStump", "meshSnowyForestTerrainWater", "meshSnowyForestTreeLog1Collision",
			"meshSnowyForestTreeLog2Collision", "meshSnowyForestRockLGCollision", "meshSnowyForestTreeTrunk2Collison", "meshFirpitCollision", "meshSPTerrain", "meshSPGroundSpikes", "meshSPDome", "meshSPCaveEntrance", "meshSPSphereBaseLG", "meshSPSphereBaseSM",
			"meshSPSphereBKLG", "meshSPSphereBKMD", "meshSPSphereBKSM", "meshSPSphere", "Terrain Middle", "Terrain North", "Terrain South", "Terrain Random", "Wall NorthWest", "Wall East",
			"Tree Gianticus", "Tree Big Bottom", "Tree Downed", "Tree Downed Top Section", "Tree Downed Ring", "Tree Root Random West", "Root Bridge", "Root Bridge Front", "Root1", "Root2",
			"Root3", "Root 4", "Rock Holder", "Rock Holder 2", "Rock Random", "Random Rock Root", "Rock Raised", "Rock Raised 2", "Rock Raised 3", "Rock Raised 4",
			"Rock Raised 5", "Rock", "Vine Tree", "Triangle_low", "Moss Cover", "Moss Cover Rock Holder", "Moss Cover Root Bridge Front", "BigShroom_low", "Shelf_low", "SmallLeaf_low",
			"mdlVoidTerrainMain", "mdlVoidTerrainRoofCavernNE", "mdlVoidTerrainRoofCavernNW", "mdlVoidTerrainFloorCavernSW", "mdlVoidTerrainTowerRoofCavernSW", "mdlVoidTerrainNW", "mdlVoidTerrainNE", "mdlVoidTerrainSE", "mdlVoidTerrainEastSmall", "mdlVoidTerrainSouthSmall",
			"mdlVoidTerrainSouthSmallRoof", "mdlVoidTerrainNESmallBridge", "mdlVoidRepairsPlatform", "mdlVoidRepairsPlatformWalls", "mdlVoidRepairsPlatformWalls.001", "mdlVoidRepairsPlatformWallsSidebits", "mdlVoidSupportPlatform", "mdlVoidSupportPlatform.002", "mdlVoidSupportPlatformFloating", "mdlVoidSupportPlatformFloatingSubpiece",
			"mdlVoidEastPlatform", "mdlVoidMetalSpiralWalkway", "mdlVoidWalkwayGenericBaseLong.001", "mdlVoidShrine", "mdlGravityShrineEnd", "mdlGravityCollarGenericBase", "mdlVoidPiecemealBridge1", "mdlVoidPiecemealBridge2", "mdlVoidPlatformBridge1", "mdlVoidPlatformBridge2",
			"mdlVoidPlatformBridge3", "mdlVoidPlatformBridge5", "mdlVoidPlatformBridge6", "mdlVoidPlatformBridge7", "mdlVoidRuinArchFloating1", "mdlVoidRuinArchFloating2", "mdlVoidArchEntry.001", "mdlVoidCoralPlatformTypeA.001", "mdlVoidCoralPlatformTypeA.002", "mdlVoidCoralPlatformTypeA.004",
			"mdlVoidCoralPlatformTypeB.001", "mdlVoidStageRing.001", "mdlVoidStageRing.002", "mdlVoidStageRing.003", "mdlVoidStageRing.004", "mdlVoidStageRing.005", "mdlVoidStageRing.006"
		};

		private static string cachedScene;

		private static List<BundleMeshCore.MeshBlob> cachedBlobs;

		public static bool Whitelisted(Mesh mesh)
		{
			return Whitelist.Contains(((Object)mesh).name);
		}

		public static void DropCache()
		{
			cachedScene = null;
			cachedBlobs = null;
		}

		public static Data TryRead(Mesh mesh)
		{
			try
			{
				BundleMeshCore.MeshBlob meshBlob = FindBlob(mesh);
				if (meshBlob == null)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)$"[ScorchedVoxels] mesh '{((Object)mesh).name}' ({mesh.vertexCount} verts) not found in this stage's bundles — left vanilla");
					return null;
				}
				Data data = Convert(meshBlob);
				int num = 0;
				int[][] subTris = data.subTris;
				foreach (int[] array in subTris)
				{
					num += array.Length / 3;
				}
				ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] non-readable mesh '" + ((Object)mesh).name + "' loaded from the game's bundle files: " + $"{data.verts.Length} verts, {num} tris, uv0={data.uv0 != null}, uv2={data.uv2 != null}, colors={data.colors != null}"));
				return data;
			}
			catch (Exception ex)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] bundle read failed for whitelisted mesh '" + ((Object)mesh).name + "' (" + ex.Message + ") — left vanilla"));
				return null;
			}
		}

		private static BundleMeshCore.MeshBlob FindBlob(Mesh mesh)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (cachedScene != name || cachedBlobs == null)
			{
				cachedScene = name;
				cachedBlobs = LoadSceneBlobs(name);
			}
			foreach (BundleMeshCore.MeshBlob cachedBlob in cachedBlobs)
			{
				if (cachedBlob.name == ((Object)mesh).name && cachedBlob.vertexCount == mesh.vertexCount && cachedBlob.subMeshCount == mesh.subMeshCount)
				{
					return cachedBlob;
				}
			}
			return null;
		}

		private static List<BundleMeshCore.MeshBlob> LoadSceneBlobs(string scene)
		{
			List<BundleMeshCore.MeshBlob> list = new List<BundleMeshCore.MeshBlob>();
			string text = Path.Combine(Application.streamingAssetsPath, "aa", "StandaloneWindows64");
			if (!Directory.Exists(text))
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] addressables directory not found: " + text));
				return list;
			}
			string value = scene.ToLowerInvariant();
			string[] files = Directory.GetFiles(text, "*.bundle");
			foreach (string text2 in files)
			{
				if (Path.GetFileName(text2).ToLowerInvariant().IndexOf(value, StringComparison.Ordinal) >= 0)
				{
					try
					{
						list.AddRange(BundleMeshCore.LoadMeshes(text2, Whitelist));
					}
					catch (Exception ex)
					{
						ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] could not parse bundle '" + Path.GetFileName(text2) + "' (" + ex.Message + ")"));
					}
				}
			}
			return list;
		}

		private static Data Convert(BundleMeshCore.MeshBlob b)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00f2: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			Data data = new Data
			{
				subTris = b.subTris
			};
			data.verts = (Vector3[])(object)new Vector3[b.vertexCount];
			for (int i = 0; i < b.vertexCount; i++)
			{
				data.verts[i] = new Vector3(b.positions[i * 3], b.positions[i * 3 + 1], b.positions[i * 3 + 2]);
			}
			if (b.uv0 != null)
			{
				data.uv0 = (Vector2[])(object)new Vector2[b.vertexCount];
				for (int j = 0; j < b.vertexCount; j++)
				{
					data.uv0[j] = new Vector2(b.uv0[j * 2], b.uv0[j * 2 + 1]);
				}
			}
			if (b.uv1 != null)
			{
				data.uv2 = (Vector2[])(object)new Vector2[b.vertexCount];
				for (int k = 0; k < b.vertexCount; k++)
				{
					data.uv2[k] = new Vector2(b.uv1[k * 2], b.uv1[k * 2 + 1]);
				}
			}
			if (b.colors != null)
			{
				data.colors = (Color32[])(object)new Color32[b.vertexCount];
				for (int l = 0; l < b.vertexCount; l++)
				{
					data.colors[l] = new Color32(b.colors[l * 4], b.colors[l * 4 + 1], b.colors[l * 4 + 2], b.colors[l * 4 + 3]);
				}
			}
			return data;
		}
	}
	internal class SourceMesh
	{
		public string name;

		public Vector3[] verts;

		public int[] indices;

		public Material material;

		public MeshRenderer renderer;

		public MeshCollider collider;

		public Material[] materials;

		public int[] subOfTri;

		public int dominantSub;

		public Vector2[] uv0;

		public Color32[] colors;

		public Vector3[] triCenter;

		public float[] triRadius;

		public Vector2[] uv2;

		public int lightmapIndex = -1;

		public Vector4 lightmapScaleOffset;

		public float carveScale = 1f;

		public bool openShell;

		public Vector3[] pnVertA;

		public Vector3[] pnVertB;

		public Vector3[] pnVertC;

		public Vector3[] pnEdgeAB;

		public Vector3[] pnEdgeBC;

		public Vector3[] pnEdgeCA;

		public WindingField winding;

		public bool indicesAliasShared;

		public bool hasVisibleRenderer;

		public ShadowCastingMode shadowMode = (ShadowCastingMode)1;

		public int TriCount => indices.Length / 3;
	}
	internal static class MeshVoxelizer
	{
		private sealed class TriBin
		{
			public int[] tris;

			public int n;
		}

		private const float BinMargin = 2f;

		private const int MaxBandChunks = 150000;

		internal const float ShellDepth = 4f;

		private const long MaxTriChunks = 8192L;

		[ThreadStatic]
		private static Vector3[] tsFa;

		[ThreadStatic]
		private static Vector3[] tsFb;

		[ThreadStatic]
		private static Vector3[] tsFc;

		[ThreadStatic]
		private static Vector3[] tsFn;

		[ThreadStatic]
		private static Vector3[] tsFsc;

		[ThreadStatic]
		private static float[] tsFsr;

		[ThreadStatic]
		private static float[] tsCoarse;

		public static List<VoxelVolume> Build(List<SourceMesh> sources, float desiredVoxelSize, Func<bool> isCancelled)
		{
			//IL_035b: 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_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			float num = desiredVoxelSize;
			for (int i = 0; i < 12; i++)
			{
				int num2 = CountBandChunks(sources, num);
				if (num2 <= 150000)
				{
					break;
				}
				float num3 = num * 1.3f;
				if (ModOptions.VerboseLogging.Value)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] {num2} band chunks at VoxelSize {num:F2}m exceeds budget {150000} — coarsening to {num3:F2}m");
				}
				num = num3;
			}
			float num4 = 16f * num;
			float margin = 2f * num;
			int num5 = 0;
			int num6 = 0;
			List<VoxelVolume> list = new List<VoxelVolume>();
			List<VoxelVolume> workVolume = new List<VoxelVolume>();
			List<SourceMesh> workSource = new List<SourceMesh>();
			List<long> workKey = new List<long>();
			List<int[]> workTris = new List<int[]>();
			for (int j = 0; j < sources.Count; j++)
			{
				SourceMesh sourceMesh = sources[j];
				Dictionary<long, TriBin> dictionary = new Dictionary<long, TriBin>();
				int num7 = int.MaxValue;
				int num8 = int.MaxValue;
				int num9 = int.MaxValue;
				int num10 = int.MinValue;
				int num11 = int.MinValue;
				int num12 = int.MinValue;
				for (int k = 0; k < sourceMesh.indices.Length; k += 3)
				{
					if (!TriChunkRange(sourceMesh, k, num4, margin, out var x, out var x2, out var y, out var y2, out var z, out var z2))
					{
						num5++;
						continue;
					}
					for (int l = x; l <= x2; l++)
					{
						for (int m = y; m <= y2; m++)
						{
							for (int n = z; n <= z2; n++)
							{
								long key = VoxelVolume.PackKey(l, m, n);
								if (!dictionary.TryGetValue(key, out var value))
								{
									value = (dictionary[key] = new TriBin());
								}
								value.n++;
								if (l < num7)
								{
									num7 = l;
								}
								if (l > num10)
								{
									num10 = l;
								}
								if (m < num8)
								{
									num8 = m;
								}
								if (m > num11)
								{
									num11 = m;
								}
								if (n < num9)
								{
									num9 = n;
								}
								if (n > num12)
								{
									num12 = n;
								}
							}
						}
					}
				}
				if (dictionary.Count == 0)
				{
					continue;
				}
				foreach (KeyValuePair<long, TriBin> item in dictionary)
				{
					item.Value.tris = new int[item.Value.n];
					item.Value.n = 0;
				}
				for (int num13 = 0; num13 < sourceMesh.indices.Length; num13 += 3)
				{
					if (!TriChunkRange(sourceMesh, num13, num4, margin, out var x3, out var x4, out var y3, out var y4, out var z3, out var z4))
					{
						continue;
					}
					for (int num14 = x3; num14 <= x4; num14++)
					{
						for (int num15 = y3; num15 <= y4; num15++)
						{
							for (int num16 = z3; num16 <= z4; num16++)
							{
								TriBin triBin2 = dictionary[VoxelVolume.PackKey(num14, num15, num16)];
								triBin2.tris[triBin2.n++] = num13 / 3;
							}
						}
					}
				}
				SourceMesh sourceMesh2 = sourceMesh;
				if (sourceMesh2.winding == null)
				{
					sourceMesh2.winding = new WindingField(sourceMesh.verts, sourceMesh.indices);
				}
				if (sourceMesh.pnVertA == null)
				{
					ComputePseudonormals(sourceMesh);
				}
				Vector3 val = sourceMesh.verts[0];
				Vector3 val2 = sourceMesh.verts[0];
				Vector3[] verts = sourceMesh.verts;
				foreach (Vector3 val3 in verts)
				{
					val = Vector3.Min(val, val3);
					val2 = Vector3.Max(val2, val3);
				}
				Bounds meshBoundsWS = default(Bounds);
				((Bounds)(ref meshBoundsWS)).SetMinMax(val, val2);
				VoxelVolume voxelVolume = new VoxelVolume(num)
				{
					material = sourceMesh.material,
					materials = sourceMesh.materials,
					dominantSub = sourceMesh.dominantSub,
					carveScale = sourceMesh.carveScale,
					openShell = sourceMesh.openShell,
					winding = sourceMesh.winding,
					meshBoundsWS = meshBoundsWS,
					index = j,
					priority = sourceMesh.TriCount,
					name = sourceMesh.name,
					source = sourceMesh,
					lightmapIndex = sourceMesh.lightmapIndex,
					lightmapScaleOffset = sourceMesh.lightmapScaleOffset,
					renderable = sourceMesh.hasVisibleRenderer,
					shadowMode = sourceMesh.shadowMode
				};
				Vector3 val4 = new Vector3((float)num7, (float)num8, (float)num9) * num4 - Vector3.one * 4f;
				Vector3 val5 = new Vector3((float)(num10 + 1), (float)(num11 + 1), (float)(num12 + 1)) * num4 + Vector3.one * 4f;
				val4.y -= 300f;
				Bounds boundsWS = default(Bounds);
				((Bounds)(ref boundsWS)).SetMinMax(val4, val5);
				voxelVolume.boundsWS = boundsWS;
				list.Add(voxelVolume);
				foreach (KeyValuePair<long, TriBin> item2 in dictionary)
				{
					workVolume.Add(voxelVolume);
					workSource.Add(sourceMesh);
					workKey.Add(item2.Key);
					workTris.Add(item2.Value.tris);
				}
				num6 += dictionary.Count;
			}
			if (ModOptions.VerboseLogging.Value)
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)($"[ScorchedVoxels] binned {num6} band chunks across {list.Count} volumes at voxel {num:F2}m" + ((num5 > 0) ? $" ({num5} backdrop-scale tris skipped)" : "")));
			}
			ConvertProgress.Set("voxelizing terrain", workKey.Count);
			byte[][] results = new byte[workKey.Count][];
			int num18 = Mathf.Clamp(Environment.ProcessorCount - 2, 1, 14);
			Task[] array = new Task[num18];
			int cursor = -1;
			for (int num19 = 0; num19 < num18; num19++)
			{
				array[num19] = Task.Run(delegate
				{
					while (true)
					{
						int num22 = Interlocked.Increment(ref cursor);
						if (num22 >= workKey.Count || isCancelled())
						{
							break;
						}
						results[num22] = BuildChunkDensity(workVolume[num22], workSource[num22], workTris[num22], workKey[num22]);
						Interlocked.Increment(ref ConvertProgress.Done);
					}
				});
			}
			Task.WaitAll(array);
			foreach (SourceMesh source in sources)
			{
				source.pnVertA = (source.pnVertB = (source.pnVertC = (source.pnEdgeAB = (source.pnEdgeBC = (source.pnEdgeCA = null)))));
			}
			if (isCancelled())
			{
				return list;
			}
			for (int num20 = 0; num20 < workKey.Count; num20++)
			{
				if (results[num20] != null)
				{
					long num21 = workKey[num20];
					int cx = VoxelVolume.UnpackSigned(num21 >> 42);
					int cy = VoxelVolume.UnpackSigned(num21 >> 21);
					int cz = VoxelVolume.UnpackSigned(num21);
					workVolume[num20].AddBandChunk(cx, cy, cz, results[num20]).srcTris = workTris[num20];
				}
			}
			foreach (VoxelVolume item3 in list)
			{
				item3.SortColumns();
			}
			return list;
		}

		private static void ComputePseudonormals(SourceMesh src)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_015e: 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_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_0169: 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_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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: 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)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] verts = src.verts;
			int[] indices = src.indices;
			int num = indices.Length / 3;
			Dictionary<Vector3, int> dictionary = new Dictionary<Vector3, int>(verts.Length);
			int[] array = new int[verts.Length];
			for (int i = 0; i < verts.Length; i++)
			{
				if (!dictionary.TryGetValue(verts[i], out var value))
				{
					value = dictionary.Count;
					dictionary[verts[i]] = value;
				}
				array[i] = value;
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[dictionary.Count];
			Dictionary<long, Vector3> dictionary2 = new Dictionary<long, Vector3>(num * 2, GoreSkeleton.EdgeKeyComparer.Instance);
			for (int j = 0; j < num; j++)
			{
				int num2 = indices[j * 3];
				int num3 = indices[j * 3 + 1];
				int num4 = indices[j * 3 + 2];
				Vector3 val = verts[num2];
				Vector3 val2 = verts[num3];
				Vector3 val3 = verts[num4];
				Vector3 val4 = Vector3.Cross(val2 - val, val3 - val);
				float magnitude = ((Vector3)(ref val4)).magnitude;
				if (!(magnitude < 1E-12f))
				{
					Vector3 val5 = val4 / magnitude;
					int num5 = array[num2];
					int num6 = array[num3];
					int num7 = array[num4];
					ref Vector3 reference = ref array2[num5];
					reference += val5 * Corner(val2 - val, val3 - val);
					ref Vector3 reference2 = ref array2[num6];
					reference2 += val5 * Corner(val - val2, val3 - val2);
					ref Vector3 reference3 = ref array2[num7];
					reference3 += val5 * Corner(val - val3, val2 - val3);
					long key = EdgeKey(num5, num6);
					long key2 = EdgeKey(num6, num7);
					long key3 = EdgeKey(num7, num5);
					dictionary2.TryGetValue(key, out var value2);
					dictionary2[key] = value2 + val5;
					dictionary2.TryGetValue(key2, out var value3);
					dictionary2[key2] = value3 + val5;
					dictionary2.TryGetValue(key3, out var value4);
					dictionary2[key3] = value4 + val5;
				}
			}
			src.pnVertA = (Vector3[])(object)new Vector3[num];
			src.pnVertB = (Vector3[])(object)new Vector3[num];
			src.pnVertC = (Vector3[])(object)new Vector3[num];
			src.pnEdgeAB = (Vector3[])(object)new Vector3[num];
			src.pnEdgeBC = (Vector3[])(object)new Vector3[num];
			src.pnEdgeCA = (Vector3[])(object)new Vector3[num];
			for (int k = 0; k < num; k++)
			{
				int num8 = array[indices[k * 3]];
				int num9 = array[indices[k * 3 + 1]];
				int num10 = array[indices[k * 3 + 2]];
				src.pnVertA[k] = array2[num8];
				src.pnVertB[k] = array2[num9];
				src.pnVertC[k] = array2[num10];
				dictionary2.TryGetValue(EdgeKey(num8, num9), out src.pnEdgeAB[k]);
				dictionary2.TryGetValue(EdgeKey(num9, num10), out src.pnEdgeBC[k]);
				dictionary2.TryGetValue(EdgeKey(num10, num8), out src.pnEdgeCA[k]);
			}
			static float Corner(Vector3 u, Vector3 v)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				float magnitude2 = ((Vector3)(ref u)).magnitude;
				float magnitude3 = ((Vector3)(ref v)).magnitude;
				if (magnitude2 < 1E-09f || magnitude3 < 1E-09f)
				{
					return 0f;
				}
				return Mathf.Acos(Mathf.Clamp(Vector3.Dot(u, v) / (magnitude2 * magnitude3), -1f, 1f));
			}
			static long EdgeKey(int a, int b)
			{
				if (a >= b)
				{
					return ((long)b << 32) | (uint)a;
				}
				return ((long)a << 32) | (uint)b;
			}
		}

		private static bool TriChunkRange(SourceMesh src, int t, float chunkWorld, float margin, out int x0, out int x1, out int y0, out int y1, out int z0, out int z1)
		{
			//IL_000e: 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)
			//IL_0028: 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)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_0079: 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_008c: 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_00ac: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = src.verts[src.indices[t]];
			Vector3 val2 = src.verts[src.indices[t + 1]];
			Vector3 val3 = src.verts[src.indices[t + 2]];
			Vector3 val4 = Vector3.Min(val, Vector3.Min(val2, val3)) - Vector3.one * margin;
			Vector3 val5 = Vector3.Max(val, Vector3.Max(val2, val3)) + Vector3.one * margin;
			x0 = Mathf.FloorToInt(val4.x / chunkWorld);
			x1 = Mathf.FloorToInt(val5.x / chunkWorld);
			y0 = Mathf.FloorToInt(val4.y / chunkWorld);
			y1 = Mathf.FloorToInt(val5.y / chunkWorld);
			z0 = Mathf.FloorToInt(val4.z / chunkWorld);
			z1 = Mathf.FloorToInt(val5.z / chunkWorld);
			return (long)(x1 - x0 + 1) * (long)(y1 - y0 + 1) * (z1 - z0 + 1) <= 8192;
		}

		private static int CountBandChunks(List<SourceMesh> sources, float vs)
		{
			float chunkWorld = 16f * vs;
			float margin = 2f * vs;
			int num = 0;
			HashSet<long> hashSet = new HashSet<long>();
			for (int i = 0; i < sources.Count; i++)
			{
				hashSet.Clear();
				SourceMesh sourceMesh = sources[i];
				for (int j = 0; j < sourceMesh.indices.Length; j += 3)
				{
					if (!TriChunkRange(sourceMesh, j, chunkWorld, margin, out var x, out var x2, out var y, out var y2, out var z, out var z2))
					{
						continue;
					}
					for (int k = x; k <= x2; k++)
					{
						for (int l = y; l <= y2; l++)
						{
							for (int m = z; m <= z2; m++)
							{
								hashSet.Add(VoxelVolume.PackKey(k, l, m));
							}
						}
					}
				}
				num += hashSet.Count;
			}
			return num;
		}

		private static byte[] BuildChunkDensity(VoxelVolume vol, SourceMesh src, int[] tris, long key)
		{
			//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_0140: 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_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_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: 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_01de: 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_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: 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_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: 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)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			int num = VoxelVolume.UnpackSigned(key >> 42);
			int num2 = VoxelVolume.UnpackSigned(key >> 21);
			int num3 = VoxelVolume.UnpackSigned(key);
			float voxelSize = vol.voxelSize;
			int num4 = 16;
			int triCount = tris.Length;
			if (tsFa == null || tsFa.Length < triCount)
			{
				int num5 = Mathf.NextPowerOfTwo(triCount);
				tsFa = (Vector3[])(object)new Vector3[num5];
				tsFb = (Vector3[])(object)new Vector3[num5];
				tsFc = (Vector3[])(object)new Vector3[num5];
				tsFn = (Vector3[])(object)new Vector3[num5];
				tsFsc = (Vector3[])(object)new Vector3[num5];
				tsFsr = new float[num5];
			}
			Vector3[] fa = tsFa;
			Vector3[] fb = tsFb;
			Vector3[] fc = tsFc;
			Vector3[] fn = tsFn;
			Vector3[] fsc = tsFsc;
			float[] fsr = tsFsr;
			for (int i = 0; i < triCount; i++)
			{
				int num6 = tris[i] * 3;
				Vector3 val = src.verts[src.indices[num6]];
				Vector3 val2 = src.verts[src.indices[num6 + 1]];
				Vector3 val3 = src.verts[src.indices[num6 + 2]];
				fa[i] = val;
				fb[i] = val2;
				fc[i] = val3;
				fn[i] = Vector3.Cross(val2 - val, val3 - val);
				Vector3 val4 = (val + val2 + val3) / 3f;
				fsc[i] = val4;
				float[] array = fsr;
				int num7 = i;
				Vector3 val5 = val - val4;
				float sqrMagnitude = ((Vector3)(ref val5)).sqrMagnitude;
				val5 = val2 - val4;
				float sqrMagnitude2 = ((Vector3)(ref val5)).sqrMagnitude;
				val5 = val3 - val4;
				array[num7] = Mathf.Sqrt(Mathf.Max(sqrMagnitude, Mathf.Max(sqrMagnitude2, ((Vector3)(ref val5)).sqrMagnitude)));
			}
			int warm = -1;
			float[] array2 = tsCoarse ?? (tsCoarse = new float[512]);
			Vector3 p = default(Vector3);
			for (int j = 0; j < 8; j++)
			{
				for (int k = 0; k < 8; k++)
				{
					for (int l = 0; l < 8; l++)
					{
						((Vector3)(ref p))..ctor(((float)((num << 4) + l * 2) + 0.5f) * voxelSize, ((float)((num2 << 4) + j * 2) + 0.5f) * voxelSize, ((float)((num3 << 4) + k * 2) + 0.5f) * voxelSize);
						array2[(j * 8 + k) * 8 + l] = ExactSigned(p);
					}
				}
			}
			float num8 = 2.25f * voxelSize;
			float num9 = 3.25f * voxelSize;
			bool openShell = vol.openShell;
			Bounds meshBoundsWS = vol.meshBoundsWS;
			((Bounds)(ref meshBoundsWS)).Expand(2f * voxelSize);
			Vector3 min = ((Bounds)(ref meshBoundsWS)).min;
			Vector3 max = ((Bounds)(ref meshBoundsWS)).max;
			byte[] array3 = new byte[num4 * num4 * num4];
			Vector3 val6 = default(Vector3);
			for (int m = 0; m < num4; m++)
			{
				for (int n = 0; n < num4; n++)
				{
					for (int num10 = 0; num10 < num4; num10++)
					{
						float num11 = array2[((m >> 1) * 8 + (n >> 1)) * 8 + (num10 >> 1)];
						byte b;
						if (openShell)
						{
							((Vector3)(ref val6))..ctor(((float)((num << 4) + num10) + 0.5f) * voxelSize, ((float)((num2 << 4) + m) + 0.5f) * voxelSize, ((float)((num3 << 4) + n) + 0.5f) * voxelSize);
							bool flag = val6.x >= min.x && val6.x <= max.x && val6.y >= min.y && val6.y <= max.y && val6.z >= min.z && val6.z <= max.z;
							if (num11 > num9)
							{
								b = 0;
							}
							else if (num11 < 0f - num8 && flag)
							{
								b = byte.MaxValue;
							}
							else if (num11 < 0f - (4f + num8))
							{
								b = 0;
							}
							else
							{
								float num12 = ExactSigned(val6);
								float num13 = (flag ? float.MaxValue : (0.5f + (num12 + 4f) / voxelSize));
								b = (byte)(Mathf.Clamp01(Mathf.Min(0.5f - num12 / voxelSize, num13)) * 255f);
							}
						}
						else if (num11 > num8)
						{
							b = 0;
						}
						else if (num11 < 0f - num8)
						{
							b = byte.MaxValue;
						}
						else
						{
							float num14 = ExactSigned(new Vector3(((float)((num << 4) + num10) + 0.5f) * voxelSize, ((float)((num2 << 4) + m) + 0.5f) * voxelSize, ((float)((num3 << 4) + n) + 0.5f) * voxelSize));
							b = (byte)(Mathf.Clamp01(0.5f - num14 / voxelSize) * 255f);
						}
						array3[VoxelVolume.VoxelIndex(num10, m, n)] = b;
					}
				}
			}
			return array3;
			float ExactSigned(Vector3 val7)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: 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_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: 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_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: 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_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_020c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: 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_023a: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_0232: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				float num15 = float.MaxValue;
				float num16 = float.MaxValue;
				int num17 = -1;
				if (warm >= 0)
				{
					num15 = PointTriDistSq(val7, fa[warm], fb[warm], fc[warm]);
					num16 = Mathf.Sqrt(num15);
					num17 = warm;
				}
				for (int num18 = 0; num18 < triCount; num18++)
				{
					if (num17 >= 0)
					{
						if (num18 == num17)
						{
							continue;
						}
						float num19 = val7.x - fsc[num18].x;
						float num20 = val7.y - fsc[num18].y;
						float num21 = val7.z - fsc[num18].z;
						float num22 = fsr[num18] + num16;
						if (num19 * num19 + num20 * num20 + num21 * num21 > num22 * num22)
						{
							continue;
						}
					}
					float num23 = PointTriDistSq(val7, fa[num18], fb[num18], fc[num18]);
					if (num23 < num15)
					{
						num15 = num23;
						num16 = Mathf.Sqrt(num23);
						num17 = num18;
					}
				}
				if (num17 < 0)
				{
					return float.MaxValue;
				}
				warm = num17;
				PointTriClosest(val7, fa[num17], fb[num17], fc[num17], out var cp, out var feature);
				int num24 = tris[num17];
				Vector3 val8 = (Vector3)(feature switch
				{
					0 => src.pnVertA[num24], 
					1 => src.pnVertB[num24], 
					2 => src.pnVertC[num24], 
					3 => src.pnEdgeAB[num24], 
					4 => src.pnEdgeBC[num24], 
					5 => src.pnEdgeCA[num24], 
					_ => fn[num17], 
				});
				if (!(Vector3.Dot(val7 - cp, val8) >= 0f))
				{
					return 0f - num16;
				}
				return num16;
			}
		}

		private static float PointTriDistSq(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//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_000f: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_0100: 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_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_00b6: 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_00b8: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//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_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: 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)
			Vector3 val = b - a;
			Vector3 val2 = c - a;
			Vector3 val3 = p - a;
			float num = Vector3.Dot(val, val3);
			float num2 = Vector3.Dot(val2, val3);
			Vector3 val4;
			if (num <= 0f && num2 <= 0f)
			{
				val4 = p - a;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			Vector3 val5 = p - b;
			float num3 = Vector3.Dot(val, val5);
			float num4 = Vector3.Dot(val2, val5);
			if (num3 >= 0f && num4 <= num3)
			{
				val4 = p - b;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num5 = num * num4 - num3 * num2;
			if (num5 <= 0f && num >= 0f && num3 <= 0f)
			{
				float num6 = num / (num - num3);
				val4 = p - (a + val * num6);
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			Vector3 val6 = p - c;
			float num7 = Vector3.Dot(val, val6);
			float num8 = Vector3.Dot(val2, val6);
			if (num8 >= 0f && num7 <= num8)
			{
				val4 = p - c;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num9 = num7 * num2 - num * num8;
			if (num9 <= 0f && num2 >= 0f && num8 <= 0f)
			{
				float num10 = num2 / (num2 - num8);
				val4 = p - (a + val2 * num10);
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num11 = num3 * num8 - num7 * num4;
			if (num11 <= 0f && num4 - num3 >= 0f && num7 - num8 >= 0f)
			{
				float num12 = (num4 - num3) / (num4 - num3 + (num7 - num8));
				val4 = p - (b + (c - b) * num12);
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num13 = 1f / (num11 + num9 + num5);
			float num14 = num9 * num13;
			float num15 = num5 * num13;
			val4 = p - (a + val * num14 + val2 * num15);
			return ((Vector3)(ref val4)).sqrMagnitude;
		}

		internal static float PointTriClosest(Vector3 p, Vector3 a, Vector3 b, Vector3 c, out Vector3 cp, out int feature)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//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_000f: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0046: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: 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_0108: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: 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_0266: 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_017a: 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_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_0188: 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_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: 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)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: 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_020b: 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)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = b - a;
			Vector3 val2 = c - a;
			Vector3 val3 = p - a;
			float num = Vector3.Dot(val, val3);
			float num2 = Vector3.Dot(val2, val3);
			Vector3 val4;
			if (num <= 0f && num2 <= 0f)
			{
				cp = a;
				feature = 0;
				val4 = p - a;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			Vector3 val5 = p - b;
			float num3 = Vector3.Dot(val, val5);
			float num4 = Vector3.Dot(val2, val5);
			if (num3 >= 0f && num4 <= num3)
			{
				cp = b;
				feature = 1;
				val4 = p - b;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num5 = num * num4 - num3 * num2;
			if (num5 <= 0f && num >= 0f && num3 <= 0f)
			{
				float num6 = num / (num - num3);
				cp = a + val * num6;
				feature = 3;
				val4 = p - cp;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			Vector3 val6 = p - c;
			float num7 = Vector3.Dot(val, val6);
			float num8 = Vector3.Dot(val2, val6);
			if (num8 >= 0f && num7 <= num8)
			{
				cp = c;
				feature = 2;
				val4 = p - c;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num9 = num7 * num2 - num * num8;
			if (num9 <= 0f && num2 >= 0f && num8 <= 0f)
			{
				float num10 = num2 / (num2 - num8);
				cp = a + val2 * num10;
				feature = 5;
				val4 = p - cp;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num11 = num3 * num8 - num7 * num4;
			if (num11 <= 0f && num4 - num3 >= 0f && num7 - num8 >= 0f)
			{
				float num12 = (num4 - num3) / (num4 - num3 + (num7 - num8));
				cp = b + (c - b) * num12;
				feature = 4;
				val4 = p - cp;
				return ((Vector3)(ref val4)).sqrMagnitude;
			}
			float num13 = 1f / (num11 + num9 + num5);
			float num14 = num9 * num13;
			float num15 = num5 * num13;
			cp = a + val * num14 + val2 * num15;
			feature = 6;
			val4 = p - cp;
			return ((Vector3)(ref val4)).sqrMagnitude;
		}
	}
	internal static class NodeGraphAdjuster
	{
		private struct PendingAdjust
		{
			public Vector3 pos;

			public float r;

			public float due;
		}

		private const float MaxNodeDrop = 4f;

		private const float SettleDelay = 0.75f;

		private static readonly FieldInfo NodesField = typeof(NodeGraph).GetField("nodes", BindingFlags.Instance | BindingFlags.NonPublic);

		private static NodeGraph graph;

		private static Node[] nodes;

		private static Node[] backup;

		private static readonly List<PendingAdjust> queue = new List<PendingAdjust>();

		public static void OnStageStart()
		{
			graph = null;
			nodes = null;
			backup = null;
			queue.Clear();
		}

		public static Vector3[] GroundNodePositions()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			SceneInfo instance = SceneInfo.instance;
			NodeGraph val = (((Object)(object)instance != (Object)null) ? instance.groundNodes : null);
			Node[] array = (((Object)(object)val != (Object)null) ? (NodesField.GetValue(val) as Node[]) : null);
			if (array == null || array.Length == 0)
			{
				return Array.Empty<Vector3>();
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array2[i] = array[i].position;
			}
			return array2;
		}

		public static void Restore()
		{
			try
			{
				if (nodes != null && backup != null && nodes.Length == backup.Length)
				{
					Array.Copy(backup, nodes, backup.Length);
				}
			}
			catch (Exception ex)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] node graph restore failed: " + ex.Message));
			}
			graph = null;
			nodes = null;
			backup = null;
			queue.Clear();
		}

		public static void QueueAdjust(Vector3 pos, float r)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active)
			{
				queue.Add(new PendingAdjust
				{
					pos = pos,
					r = r,
					due = Time.time + 0.75f
				});
			}
		}

		public static void Tick()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			for (int num = queue.Count - 1; num >= 0; num--)
			{
				if (!(Time.time < queue[num].due))
				{
					PendingAdjust pendingAdjust = queue[num];
					queue.RemoveAt(num);
					try
					{
						Process(pendingAdjust.pos, pendingAdjust.r);
					}
					catch (Exception ex)
					{
						ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] node adjust failed: " + ex.Message));
					}
				}
			}
		}

		private static void Process(Vector3 center, float r)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00c2: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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_01b9: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (nodes == null)
			{
				SceneInfo instance = SceneInfo.instance;
				if ((Object)(object)instance == (Object)null || NodesField == null)
				{
					return;
				}
				graph = instance.groundNodes;
				if ((Object)(object)graph == (Object)null)
				{
					return;
				}
				nodes = NodesField.GetValue(graph) as Node[];
				if (nodes == null)
				{
					return;
				}
				backup = (Node[])nodes.Clone();
			}
			LayerIndex world = LayerIndex.world;
			int num = LayerMask.op_Implicit(((LayerIndex)(ref world)).mask);
			float num2 = r + 1.5f;
			int num3 = 0;
			int num4 = 0;
			RaycastHit val = default(RaycastHit);
			for (int i = 0; i < nodes.Length; i++)
			{
				ref Node reference = ref nodes[i];
				Vector3 position = reference.position;
				float num5 = position.x - center.x;
				float num6 = position.z - center.z;
				if (num5 * num5 + num6 * num6 > num2 * num2 || Mathf.Abs(position.y - center.y) > r + 4f + 2f)
				{
					continue;
				}
				float num7 = Mathf.Max(position.y, center.y + r) + 0.75f;
				float num8 = num7 - position.y + 4f + 1.5f;
				if (Physics.Raycast(new Vector3(position.x, num7, position.z), Vector3.down, ref val, num8, num, (QueryTriggerInteraction)1))
				{
					float num9 = position.y - ((RaycastHit)(ref val)).point.y;
					if (!(num9 <= 0.2f))
					{
						if (num9 <= 4f)
						{
							reference.position = new Vector3(position.x, ((RaycastHit)(ref val)).point.y, position.z);
							num3++;
						}
						else
						{
							reference.forbiddenHulls = (HullMask)7;
							num4++;
						}
					}
				}
				else
				{
					reference.forbiddenHulls = (HullMask)7;
					num4++;
				}
			}
			if (ModOptions.VerboseLogging.Value && (num3 > 0 || num4 > 0))
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] nodes: {num3} moved into crater, {num4} forbidden");
			}
		}
	}
	[HarmonyPatch(typeof(Run), "FindSafeTeleportPositionSimplified")]
	internal static class SafeTeleportPatch
	{
		private const float FloorProbe = 8f;

		private const float DeepProbe = 90f;

		private static readonly float[] RingRadii = new float[4] { 6f, 12f, 20f, 32f };

		private static void Postfix(ref Vector3 __result)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!ModOptions.Enabled.Value || !VoxelTerrainManager.LocalConversionDone || HasFloor(__result, 8f, out var _))
				{
					return;
				}
				if (HasFloor(__result, 90f, out var floor2))
				{
					__result = floor2 + Vector3.up * 0.75f;
					return;
				}
				for (int i = 0; i < RingRadii.Length; i++)
				{
					for (int j = 0; j < 8; j++)
					{
						float num = (float)j * MathF.PI * 0.25f;
						if (HasFloor(__result + new Vector3(Mathf.Cos(num) * RingRadii[i], 0f, Mathf.Sin(num) * RingRadii[i]), 90f, out var floor3))
						{
							__result = floor3 + Vector3.up * 0.75f;
							return;
						}
					}
				}
			}
			catch (Exception e)
			{
				GoreSystem.WarnThrottled("safe teleport", e);
			}
		}

		private static bool HasFloor(Vector3 at, float depth, out Vector3 floor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = at + Vector3.up * 2f;
			Vector3 down = Vector3.down;
			float num = depth + 2f;
			LayerIndex world = LayerIndex.world;
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val, down, ref val2, num, LayerMask.op_Implicit(((LayerIndex)(ref world)).mask), (QueryTriggerInteraction)1))
			{
				floor = ((RaycastHit)(ref val2)).point;
				return true;
			}
			floor = default(Vector3);
			return false;
		}
	}
	internal static class SurfaceNets
	{
		private const int N = 16;

		private const int S = 18;

		private const int C = 17;

		[ThreadStatic]
		private static float[] samples;

		[ThreadStatic]
		private static int[] cellVert;

		[ThreadStatic]
		private static Dictionary<long, int> edgeUse;

		[ThreadStatic]
		private static Dictionary<int, int> skirtVert;

		[ThreadStatic]
		private static long[] rivalKey;

		[ThreadStatic]
		private static VoxelChunk[] rivalChunk;

		[ThreadStatic]
		private static byte[] rivalSolid;

		private static readonly int[] cornerX = new int[8] { 0, 1, 0, 1, 0, 1, 0, 1 };

		private static readonly int[] cornerY = new int[8] { 0, 0, 1, 1, 0, 0, 1, 1 };

		private static readonly int[] cornerZ = new int[8] { 0, 0, 0, 0, 1, 1, 1, 1 };

		private static readonly int[] cornerDelta = BuildCornerDeltas();

		private static readonly int[] cellEdgeA = new int[12]
		{
			0, 2, 4, 6, 0, 1, 4, 5, 0, 1,
			2, 3
		};

		private static readonly int[] cellEdgeB = new int[12]
		{
			1, 3, 5, 7, 2, 3, 6, 7, 4, 5,
			6, 7
		};

		private static int SIdx(int x, int y, int z)
		{
			return ((y + 1) * 18 + (z + 1)) * 18 + (x + 1);
		}

		private static int CIdx(int x, int y, int z)
		{
			return ((y + 1) * 17 + (z + 1)) * 17 + (x + 1);
		}

		private static int[] BuildCornerDeltas()
		{
			int[] array = new int[8];
			for (int i = 0; i < 8; i++)
			{
				array[i] = (cornerY[i] * 18 + cornerZ[i]) * 18 + cornerX[i];
			}
			return array;
		}

		public static bool Build(VoxelVolume volume, int ox, int oy, int oz, int step, byte[] fastDensity, List<VoxelVolume> rivals, List<Vector3> positions, List<Vector3> normals, List<int> indices, bool skirts = true, bool dilate = true)
		{
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			positions.Clear();
			normals.Clear();
			indices.Clear();
			if (samples == null)
			{
				samples = new float[5832];
			}
			if (cellVert == null)
			{
				cellVert = new int[4913];
			}
			if (rivals != null)
			{
				if (rivalKey == null || rivalKey.Length < rivals.Count)
				{
					rivalKey = new long[rivals.Count];
					rivalChunk = new VoxelChunk[rivals.Count];
					rivalSolid = new byte[rivals.Count];
				}
				for (int i = 0; i < rivals.Count; i++)
				{
					rivalKey[i] = long.MinValue;
					rivalChunk[i] = null;
					rivalSolid[i] = 0;
				}
			}
			float num = volume.voxelSize * (float)step;
			long lastKey = long.MinValue;
			VoxelChunk lastChunk = null;
			byte lastSolid = 0;
			for (int j = -1; j <= 16; j++)
			{
				for (int k = -1; k <= 16; k++)
				{
					for (int l = -1; l <= 16; l++)
					{
						byte b;
						if (step == 1)
						{
							b = ((fastDensity != null && (uint)l < 16u && (uint)j < 16u && (uint)k < 16u) ? fastDensity[VoxelVolume.VoxelIndex(l, j, k)] : volume.SampleCached(ox + l, oy + j, oz + k, ref lastKey, ref lastChunk, ref lastSolid));
						}
						else
						{
							int num2 = ox + l * step;
							int num3 = oy + j * step;
							int num4 = oz + k * step;
							int num5 = 0;
							int num6 = 0;
							for (int m = 0; m < step; m++)
							{
								for (int n = 0; n < step; n++)
								{
									for (int num7 = 0; num7 < step; num7++)
									{
										int num8 = volume.SampleCached(num2 + num7, num3 + m, num4 + n, ref lastKey, ref lastChunk, ref lastSolid);
										if (num8 > num5)
										{
											num5 = num8;
										}
										num6 += num8;
									}
								}
							}
							b = (dilate ? ((byte)num5) : ((byte)(num6 / (step * step * step))));
						}
						samples[SIdx(l, j, k)] = (int)b;
					}
				}
			}
			for (int num9 = 0; num9 < cellVert.Length; num9++)
			{
				cellVert[num9] = -1;
			}
			Vector3 item = default(Vector3);
			Vector3 val3 = default(Vector3);
			for (int num10 = -1; num10 < 16; num10++)
			{
				for (int num11 = -1; num11 < 16; num11++)
				{
					for (int num12 = -1; num12 < 16; num12++)
					{
						int num13 = SIdx(num12, num10, num11);
						int num14 = 0;
						for (int num15 = 0; num15 < 8; num15++)
						{
							if (samples[num13 + cornerDelta[num15]] >= 127.5f)
							{
								num14 |= 1 << num15;
							}
						}
						if (num14 == 0 || num14 == 255)
						{
							continue;
						}
						Vector3 val = Vector3.zero;
						int num16 = 0;
						for (int num17 = 0; num17 < 12; num17++)
						{
							int num18 = cellEdgeA[num17];
							int num19 = cellEdgeB[num17];
							bool num20 = (num14 & (1 << num18)) != 0;
							bool flag = (num14 & (1 << num19)) != 0;
							if (num20 != flag)
							{
								float num21 = samples[num13 + cornerDelta[num18]];
								float num22 = samples[num13 + cornerDelta[num19]];
								float num23 = (127.5f - num21) / (num22 - num21);
								val += new Vector3((float)cornerX[num18] + (float)(cornerX[num19] - cornerX[num18]) * num23, (float)cornerY[num18] + (float)(cornerY[num19] - cornerY[num18]) * num23, (float)cornerZ[num18] + (float)(cornerZ[num19] - cornerZ[num18]) * num23);
								num16++;
							}
						}
						if (num16 != 0)
						{
							Vector3 val2 = val / (float)num16;
							((Vector3)(ref item))..ctor(((float)num12 + 0.5f + val2.x) * num, ((float)num10 + 0.5f + val2.y) * num, ((float)num11 + 0.5f + val2.z) * num);
							((Vector3)(ref val3))..ctor(SampleFace(num13, 0, positive: true) - SampleFace(num13, 0, positive: false), SampleFace(num13, 1, positive: true) - SampleFace(num13, 1, positive: false), SampleFace(num13, 2, positive: true) - SampleFace(num13, 2, positive: false));
							Vector3 item2 = ((((Vector3)(ref val3)).sqrMagnitude > 1E-12f) ? (-((Vector3)(ref val3)).normalized) : Vector3.up);
							cellVert[CIdx(num12, num10, num11)] = positions.Count;
							positions.Add(item);
							normals.Add(item2);
						}
					}
				}
			}
			if (positions.Count == 0)
			{
				return false;
			}
			for (int num24 = 0; num24 < 16; num24++)
			{
				for (int num25 = 0; num25 < 16; num25++)
				{
					for (int num26 = 0; num26 < 16; num26++)
					{
						bool flag2 = samples[SIdx(num26, num24, num25)] >= 127.5f;
						int num27 = ox + num26 * step;
						int num28 = oy + num24 * step;
						int num29 = oz + num25 * step;
						if (samples[SIdx(num26 + 1, num24, num25)] >= 127.5f != flag2 && !RivalCrosses(rivals, num27, num28, num29, num27 + step, num28, num29))
						{
							EmitQuad(indices, cellVert[CIdx(num26, num24 - 1, num25 - 1)], cellVert[CIdx(num26, num24, num25 - 1)], cellVert[CIdx(num26, num24, num25)], cellVert[CIdx(num26, num24 - 1, num25)], flag2);
						}
						if (samples[SIdx(num26, num24 + 1, num25)] >= 127.5f != flag2 && !RivalCrosses(rivals, num27, num28, num29, num27, num28 + step, num29))
						{
							EmitQuad(indices, cellVert[CIdx(num26 - 1, num24, num25 - 1)], cellVert[CIdx(num26 - 1, num24, num25)], cellVert[CIdx(num26, num24, num25)], cellVert[CIdx(num26, num24, num25 - 1)], flag2);
						}
						if (samples[SIdx(num26, num24, num25 + 1)] >= 127.5f != flag2 && !RivalCrosses(rivals, num27, num28, num29, num27, num28, num29 + step))
						{
							EmitQuad(indices, cellVert[CIdx(num26 - 1, num24 - 1, num25)], cellVert[CIdx(num26, num24 - 1, num25)], cellVert[CIdx(num26, num24, num25)], cellVert[CIdx(num26 - 1, num24, num25)], flag2);
						}
					}
				}
			}
			if (indices.Count == 0)
			{
				return false;
			}
			if (step > 1 && skirts)
			{
				AddSkirts(positions, normals, indices, SkirtDepth(volume, num));
			}
			return true;
		}

		public static float SkirtDepth(VoxelVolume volume, float cellSize)
		{
			if (!volume.openShell)
			{
				return Mathf.Max(10f, 1.5f * cellSize);
			}
			return cellSize;
		}

		private static void AddSkirts(List<Vector3> positions, List<Vector3> normals, List<int> indices, float depth)
		{
			if (edgeUse == null)
			{
				edgeUse = new Dictionary<long, int>();
			}
			if (skirtVert == null)
			{
				skirtVert = new Dictionary<int, int>();
			}
			edgeUse.Clear();
			skirtVert.Clear();
			int count = indices.Count;
			for (int i = 0; i < count; i += 3)
			{
				Bump(EKey(indices[i], indices[i + 1]));
				Bump(EKey(indices[i + 1], indices[i + 2]));
				Bump(EKey(indices[i + 2], indices[i]));
			}
			foreach (KeyValuePair<long, int> item3 in edgeUse)
			{
				if (item3.Value == 1)
				{
					int num = (int)(item3.Key >> 32);
					int num2 = (int)(item3.Key & 0xFFFFFFFFu);
					int item = Sunk(num);
					int item2 = Sunk(num2);
					indices.Add(num);
					indices.Add(num2);
					indices.Add(item2);
					indices.Add(num);
					indices.Add(item2);
					indices.Add(item);
					indices.Add(num2);
					indices.Add(num);
					indices.Add(item);
					indices.Add(num2);
					indices.Add(item);
					indices.Add(item2);
				}
			}
			static void Bump(long k)
			{
				edgeUse.TryGetValue(k, out var value);
				edgeUse[k] = value + 1;
			}
			static long EKey(int a, int b)
			{
				if (a >= b)
				{
					return ((long)b << 32) | (uint)a;
				}
				return ((long)a << 32) | (uint)b;
			}
			int Sunk(int num3)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_005d: Unknown result type (might be due to invalid IL or missing references)
				if (skirtVert.TryGetValue(num3, out var value))
				{
					return value;
				}
				value = positions.Count;
				positions.Add(positions[num3] - normals[num3] * depth);
				normals.Add(normals[num3]);
				skirtVert[num3] = value;
				return value;
			}
		}

		private static bool RivalCrosses(List<VoxelVolume> rivals, int ax, int ay, int az, int bx, int by, int bz)
		{
			if (rivals == null)
			{
				return false;
			}
			for (int i = 0; i < rivals.Count; i++)
			{
				VoxelVolume voxelVolume = rivals[i];
				if (voxelVolume.chunks.TryGetValue(VoxelVolume.PackKey(ax >> 4, ay >> 4, az >> 4), out var value) && value.density != null)
				{
					bool num = (float)(int)value.density[VoxelVolume.VoxelIndex(ax & 0xF, ay & 0xF, az & 0xF)] >= 127.5f;
					bool flag = (float)(int)voxelVolume.SampleCached(bx, by, bz, ref rivalKey[i], ref rivalChunk[i], ref rivalSolid[i]) >= 127.5f;
					if (num != flag)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static float SampleFace(int baseS, int axis, bool positive)
		{
			float num = 0f;
			for (int i = 0; i < 8; i++)
			{
				if (axis switch
				{
					1 => cornerY[i], 
					0 => cornerX[i], 
					_ => cornerZ[i], 
				} == 1 == positive)
				{
					num += samples[baseS + cornerDelta[i]];
				}
			}
			return num * 0.25f;
		}

		private static void EmitQuad(List<int> indices, int v0, int v1, int v2, int v3, bool baseSolid)
		{
			if (v0 >= 0 && v1 >= 0 && v2 >= 0 && v3 >= 0)
			{
				if (baseSolid)
				{
					indices.Add(v0);
					indices.Add(v1);
					indices.Add(v2);
					indices.Add(v0);
					indices.Add(v2);
					indices.Add(v3);
				}
				else
				{
					indices.Add(v0);
					indices.Add(v3);
					indices.Add(v2);
					indices.Add(v0);
					indices.Add(v2);
					indices.Add(v1);
				}
			}
		}
	}
	internal struct CardMeta
	{
		public double m3Base;

		public int title;

		public bool titleNew;

		public int bg;

		public int runnerBest;

		public double wormsDug;

		public int prefA;

		public int prefB;

		public int prefC;

		public int nameFx;

		public void Write(NetworkWriter writer)
		{
			writer.WritePackedUInt32((uint)(title + 1));
			writer.Write(titleNew);
			writer.WritePackedUInt32((uint)bg);
			writer.WritePackedUInt32((uint)runnerBest);
			writer.Write(wormsDug);
			writer.Write((byte)((prefA < 0) ? 255u : ((uint)prefA)));
			writer.Write((byte)((prefB < 0) ? 255u : ((uint)prefB)));
			writer.Write((byte)((prefC < 0) ? 255u : ((uint)prefC)));
			writer.Write((byte)((nameFx < 0 || nameFx > 254) ? 255u : ((uint)nameFx)));
		}

		public static CardMeta Read(NetworkReader reader)
		{
			CardMeta result = new CardMeta
			{
				title = (int)(reader.ReadPackedUInt32() - 1),
				titleNew = reader.ReadBoolean(),
				bg = (int)reader.ReadPackedUInt32(),
				runnerBest = (int)reader.ReadPackedUInt32(),
				wormsDug = reader.ReadDouble()
			};
			result.prefA = ByteToPref(reader.ReadByte());
			result.prefB = ByteToPref(reader.ReadByte());
			result.prefC = ByteToPref(reader.ReadByte());
			result.nameFx = ByteToPref(reader.ReadByte());
			return result;
		}

		private static int ByteToPref(byte b)
		{
			if (b != byte.MaxValue)
			{
				return b;
			}
			return -1;
		}
	}
	internal static class RosterWire
	{
		public const byte Version = 2;

		private static float nextWarnAt;

		public static void WarnSkew(string msgName, byte got)
		{
			if (!(Time.realtimeSinceStartup < nextWarnAt))
			{
				nextWarnAt = Time.realtimeSinceStartup + 30f;
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"[ScorchedVoxels] {msgName} from a build with roster format {got} (ours {(byte)2}) — dropped. Everyone should run the same mod version.");
			}
		}
	}
	internal class CarveMessage : INetMessage, ISerializableObject
	{
		private Vector3 pos;

		private float radius;

		public CarveMessage()
		{
		}

		public CarveMessage(Vector3 pos, float radius)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			this.pos = pos;
			this.radius = radius;
		}

		public void Serialize(NetworkWriter writer)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(pos);
			writer.Write(radius);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			pos = reader.ReadVector3();
			radius = reader.ReadSingle();
		}

		public void OnReceived()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active && ModOptions.Enabled.Value)
			{
				VoxelTerrainManager.RequestCarve(pos, radius);
			}
		}
	}
	internal class GougeMessage : INetMessage, ISerializableObject
	{
		private Vector3 pos;

		private Quaternion rot;

		private Vector3 half;

		public GougeMessage()
		{
		}

		public GougeMessage(Vector3 pos, Quaternion rot, Vector3 half)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			this.pos = pos;
			this.rot = rot;
			this.half = half;
		}

		public void Serialize(NetworkWriter writer)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			writer.Write(pos);
			writer.Write(rot);
			writer.Write(half);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			pos = reader.ReadVector3();
			rot = reader.ReadQuaternion();
			half = reader.ReadVector3();
		}

		public void OnReceived()
		{
			//IL_0016: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active && ModOptions.Enabled.Value)
			{
				VoxelTerrainManager.RequestGouge(pos, rot, half);
			}
		}
	}
	internal class GougeRequestMessage : INetMessage, ISerializableObject
	{
		private Vector3 pos;

		private Quaternion rot;

		private Vector3 half;

		private uint attackerUserId;

		public GougeRequestMessage()
		{
		}

		public GougeRequestMessage(Vector3 pos, Quaternion rot, Vector3 half, uint attackerUserId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			this.pos = pos;
			this.rot = rot;
			this.half = half;
			this.attackerUserId = attackerUserId;
		}

		public void Serialize(NetworkWriter writer)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			writer.Write(pos);
			writer.Write(rot);
			writer.Write(half);
			writer.WritePackedUInt32(attackerUserId);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			pos = reader.ReadVector3();
			rot = reader.ReadQuaternion();
			half = reader.ReadVector3();
			attackerUserId = reader.ReadPackedUInt32();
		}

		public void OnReceived()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active)
			{
				VoxelTerrainManager.OnGougeRequest(pos, rot, half, attackerUserId);
			}
		}
	}
	internal class ClientConvertedMessage : INetMessage, ISerializableObject
	{
		private uint[] localUserIds = Array.Empty<uint>();

		private string modVersion = "";

		public ClientConvertedMessage()
		{
		}

		public ClientConvertedMessage(uint[] localUserIds, string modVersion)
		{
			this.localUserIds = localUserIds;
			this.modVersion = modVersion;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.Write((byte)localUserIds.Length);
			uint[] array = localUserIds;
			foreach (uint num in array)
			{
				writer.WritePackedUInt32(num);
			}
			writer.Write(modVersion);
		}

		public void Deserialize(NetworkReader reader)
		{
			localUserIds = new uint[reader.ReadByte()];
			for (int i = 0; i < localUserIds.Length; i++)
			{
				localUserIds[i] = reader.ReadPackedUInt32();
			}
			try
			{
				modVersion = reader.ReadString();
			}
			catch
			{
				modVersion = "0.7.x or older";
			}
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				StageSyncCoordinator.NotifyClientConverted(localUserIds, modVersion);
			}
		}
	}
	internal class ConvertProgressMessage : INetMessage, ISerializableObject
	{
		private uint[] userIds = Array.Empty<uint>();

		private byte percent;

		public ConvertProgressMessage()
		{
		}

		public ConvertProgressMessage(uint[] userIds, byte percent)
		{
			this.userIds = userIds;
			this.percent = percent;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.Write((byte)userIds.Length);
			uint[] array = userIds;
			foreach (uint num in array)
			{
				writer.WritePackedUInt32(num);
			}
			writer.Write(percent);
		}

		public void Deserialize(NetworkReader reader)
		{
			userIds = new uint[reader.ReadByte()];
			for (int i = 0; i < userIds.Length; i++)
			{
				userIds[i] = reader.ReadPackedUInt32();
			}
			percent = reader.ReadByte();
		}

		public void OnReceived()
		{
			if (NetworkServer.active)
			{
				StageSyncCoordinator.StoreClientProgress(userIds, percent);
			}
		}
	}
	internal class LifetimeBaseMessage : INetMessage, ISerializableObject
	{
		private byte format = 2;

		private uint[] userIds = Array.Empty<uint>();

		private CardMeta[] cards = Array.Empty<CardMeta>();

		public LifetimeBaseMessage()
		{
		}

		public LifetimeBaseMessage(uint[] userIds, CardMeta[] cards)
		{
			this.userIds = userIds;
			this.cards = cards;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.Write((byte)2);
			int num = Mathf.Min(userIds.Length, cards.Length);
			writer.Write((byte)num);
			for (int i = 0; i < num; i++)
			{
				writer.WritePackedUInt32(userIds[i]);
				writer.Write(cards[i].m3Base);
				cards[i].Write(writer);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			format = reader.ReadByte();
			if (format == 2)
			{
				int num = reader.ReadByte();
				userIds = new uint[num];
				cards = new CardMeta[num];
				for (int i = 0; i < num; i++)
				{
					userIds[i] = reader.ReadPackedUInt32();
					double m3Base = reader.ReadDouble();
					cards[i] = CardMeta.Read(reader);
					cards[i].m3Base = m3Base;
				}
			}
		}

		public void OnReceived()
		{
			if (format != 2)
			{
				RosterWire.WarnSkew("lifetime report", format);
			}
			else if (NetworkServer.active)
			{
				for (int i = 0; i < userIds.Length; i++)
				{
					StageSyncCoordinator.StoreLifetimeBase(userIds[i], in cards[i]);
				}
			}
		}
	}
	internal class StageConfigMessage : INetMessage, ISerializableObject
	{
		private int stageKey;

		private string modVersion = "";

		private bool enabled;

		private float voxelSize;

		private float minTerrainSize;

		private float maxCarveRadius;

		private string excludedNames = "";

		private float bloodAmount = 1f;

		public StageConfigMessage()
		{
		}

		public StageConfigMessage(int stageKey, string modVersion, bool enabled, float voxelSize, float minTerrainSize, float maxCarveRadius, string excludedNames, float bloodAmount)
		{
			this.stageKey = stageKey;
			this.modVersion = modVersion;
			this.enabled = enabled;
			this.voxelSize = voxelSize;
			this.minTerrainSize = minTerrainSize;
			this.maxCarveRadius = maxCarveRadius;
			this.excludedNames = excludedNames;
			this.bloodAmount = bloodAmount;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32((uint)(stageKey + 1));
			writer.Write(modVersion);
			writer.Write(enabled);
			writer.Write(voxelSize);
			writer.Write(minTerrainSize);
			writer.Write(maxCarveRadius);
			writer.Write(excludedNames);
			writer.Write(bloodAmount);
		}

		public void Deserialize(NetworkReader reader)
		{
			stageKey = (int)(reader.ReadPackedUInt32() - 1);
			modVersion = reader.ReadString();
			enabled = reader.ReadBoolean();
			voxelSize = reader.ReadSingle();
			minTerrainSize = reader.ReadSingle();
			maxCarveRadius = reader.ReadSingle();
			excludedNames = reader.ReadString();
			bloodAmount = ((reader.Position < reader.Length) ? reader.ReadSingle() : 1f);
		}

		public void OnReceived()
		{
			if (!NetworkServer.active)
			{
				VoxelTerrainManager.StoreHostConfig(stageKey, modVersion, enabled, voxelSize, minTerrainSize, maxCarveRadius, excludedNames, bloodAmount);
			}
		}
	}
	internal class LoadingSyncMessage : INetMessage, ISerializableObject
	{
		private byte format = 2;

		private bool allReady;

		private bool hostLocked;

		private List<RosterEntry> entries = new List<RosterEntry>();

		public LoadingSyncMessage()
		{
		}

		public LoadingSyncMessage(List<RosterEntry> source, bool allReady, bool hostLocked)
		{
			this.allReady = allReady;
			this.hostLocked = hostLocked;
			entries = source;
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.Write((byte)2);
			writer.Write(allReady);
			writer.Write(hostLocked);
			writer.Write((byte)Mathf.Min(entries.Count, 255));
			for (int i = 0; i < entries.Count && i < 255; i++)
			{
				RosterEntry rosterEntry = entries[i];
				writer.WritePackedUInt32(rosterEntry.userNetId);
				writer.Write(rosterEntry.ready);
				writer.Write(rosterEntry.progress);
				writer.WritePackedUInt32(rosterEntry.kills);
				writer.WritePackedUInt64(rosterEntry.damage);
				writer.WritePackedUInt64(rosterEntry.gold);
				writer.Write(rosterEntry.m3Stage);
				writer.Write(rosterEntry.m3Run);
				writer.Write(rosterEntry.m3Ever);
				for (int j = 0; j < 8; j++)
				{
					writer.Write((byte)((rosterEntry.matShare != null && j < rosterEntry.matShare.Length) ? rosterEntry.matShare[j] : 0));
				}
				CardMeta cardMeta = default(CardMeta);
				cardMeta.title = rosterEntry.title;
				cardMeta.titleNew = rosterEntry.titleNew;
				cardMeta.bg = rosterEntry.bg;
				cardMeta.runnerBest = rosterEntry.runnerBest;
				cardMeta.wormsDug = rosterEntry.wormsDug;
				cardMeta.prefA = rosterEntry.prefA;
				cardMeta.prefB = rosterEntry.prefB;
				cardMeta.prefC = rosterEntry.prefC;
				cardMeta.nameFx = rosterEntry.nameFx;
				cardMeta.Write(writer);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			format = reader.ReadByte();
			if (format != 2)
			{
				return;
			}
			allReady = reader.ReadBoolean();
			hostLocked = reader.ReadBoolean();
			int num = reader.ReadByte();
			entries = new List<RosterEntry>(num);
			for (int i = 0; i < num; i++)
			{
				RosterEntry rosterEntry = new RosterEntry
				{
					userNetId = reader.ReadPackedUInt32(),
					ready = reader.ReadBoolean(),
					progress = reader.ReadByte(),
					kills = reader.ReadPackedUInt32(),
					damage = reader.ReadPackedUInt64(),
					gold = reader.ReadPackedUInt64(),
					m3Stage = reader.ReadSingle(),
					m3Run = reader.ReadSingle(),
					m3Ever = reader.ReadDouble()
				};
				rosterEntry.matShare = new byte[8];
				for (int j = 0; j < 8; j++)
				{
					rosterEntry.matShare[j] = reader.ReadByte();
				}
				CardMeta cardMeta = CardMeta.Read(reader);
				rosterEntry.title = cardMeta.title;
				rosterEntry.titleNew = cardMeta.titleNew;
				rosterEntry.bg = cardMeta.bg;
				rosterEntry.runnerBest = cardMeta.runnerBest;
				rosterEntry.wormsDug = cardMeta.wormsDug;
				rosterEntry.prefA = cardMeta.prefA;
				rosterEntry.prefB = cardMeta.prefB;
				rosterEntry.prefC = cardMeta.prefC;
				rosterEntry.nameFx = cardMeta.nameFx;
				entries.Add(rosterEntry);
			}
		}

		public void OnReceived()
		{
			if (format != 2)
			{
				RosterWire.WarnSkew("roster heartbeat", format);
			}
			else if (!NetworkServer.active)
			{
				LoadingRoster.Entries.Clear();
				LoadingRoster.Entries.AddRange(entries);
				LoadingRoster.AllReady = allReady;
				LoadingRoster.LastSyncTime = Time.realtimeSinceStartup;
				StageSyncCoordinator.StoreHostLock(hostLocked);
				if ((Object)(object)Run.instance != (Object)null)
				{
					UserLifetimeStats.Bank();
				}
			}
		}
	}
	internal static class VoxelTerrainManager
	{
		private struct BakeItem
		{
			public VoxelChunk chunk;

			public VoxelVolume vol;

			public int meshId;
		}

		private static class ChunkMeshDataPool
		{
			private const int MaxPooled = 64;

			private static int pooled;

			private static readonly ConcurrentBag<ChunkMeshData> bag = new ConcurrentBag<ChunkMeshData>();

			public static ChunkMeshData Take()
			{
				if (bag.TryTake(out var result))
				{
					Interlocked.Decrement(ref pooled);
				}
				else
				{
					result = new ChunkMeshData
					{
						positions = new List<Vector3>(),
						normals = new List<Vector3>()
					};
				}
				result.positions.Clear();
				result.normals.Clear();
				result.indices = null;
				result.uv0 = null;
				result.uv2 = null;
				result.colors = null;
				result.subIndices = null;
				return result;
			}

			public static void Return(ChunkMeshData d)
			{
				if (d != null)
				{
					if (Interlocked.Increment(ref pooled) > 64)
					{
						Interlocked.Decrement(ref pooled);
					}
					else
					{
						bag.Add(d);
					}
				}
			}

			public static void Drop()
			{
				ChunkMeshData result;
				while (bag.TryTake(out result))
				{
					Interlocked.Decrement(ref pooled);
				}
			}
		}

		internal static class CarveWorker
		{
			internal class Job
			{
				public int epoch;

				public List<VoxelVolume> volumes;

				public Vector3 pos;

				public float r;

				public uint seed;

				public uint attacker;

				public float maxCarveRadius;

				public bool box;

				public Vector3 bpos;

				public Vector3 bax;

				public Vector3 bay;

				public Vector3 baz;

				public Vector3 bhalf;

				public List<(VoxelVolume vol, VoxelChunk chunk, long key)> rebuild;
			}

			private static readonly ConcurrentQueue<Job> jobs = new ConcurrentQueue<Job>();

			private static Thread thread;

			private static readonly AutoResetEvent wake = new AutoResetEvent(initialState: false);

			private static readonly HashSet<long> dirty = new HashSet<long>();

			private static readonly List<Vector3> wPos = new List<Vector3>();

			private static readonly List<Vector3> wNrm = new List<Vector3>();

			private static readonly List<int> wIdx = new List<int>();

			private const int MaxPooledResults = 256;

			private static int pooledResults;

			private static readonly ConcurrentBag<ChunkResult> resultPool = new ConcurrentBag<ChunkResult>();

			private static readonly ConcurrentBag<List<ChunkResult>> resultListPool = new ConcurrentBag<List<ChunkResult>>();

			private static readonly ConcurrentBag<List<long>> keyListPool = new ConcurrentBag<List<long>>();

			public static void Enqueue(Job job)
			{
				if (thread == null)
				{
					thread = new Thread(Loop)
					{
						IsBackground = true,
						Name = "ScorchedVoxels.CarveWorker"
					};
					thread.Start();
				}
				jobs.Enqueue(job);
				wake.Set();
			}

			private static void Loop()
			{
				while (true)
				{
					if (!jobs.TryDequeue(out var result))
					{
						wake.WaitOne(500);
						continue;
					}
					try
					{
						Process(result);
					}
					catch (Exception arg)
					{
						ScorchedVoxelsPlugin.Log.LogError((object)$"[ScorchedVoxels] carve worker failed: {arg}");
					}
				}
			}

			private static void Process(Job job)
			{
				//IL_0159: 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_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				if (job.volumes == null || job.epoch != CurrentEpoch)
				{
					return;
				}
				if (job.rebuild != null)
				{
					List<ChunkResult> rres = TakeResultList();
					foreach (var (vol, chunk, key) in job.rebuild)
					{
						rres.Add(TakeResult(vol, chunk, key, BuildFineChunkData(vol, chunk, key)));
					}
					List<long> emptyDirty = TakeKeyList();
					MainThread.Post(delegate
					{
						OnCarveJobDone(job, emptyDirty, rres, 0f, null);
					});
					return;
				}
				dirty.Clear();
				float num = 0f;
				VoxelVolume voxelVolume = null;
				float num2 = 0f;
				foreach (VoxelVolume volume in job.volumes)
				{
					float num3 = Mathf.Min(job.r * volume.carveScale, job.maxCarveRadius);
					if (num3 <= 0f || VoxelVolume.DistanceToBox(job.pos, ((Bounds)(ref volume.boundsWS)).min, ((Bounds)(ref volume.boundsWS)).max) > num3 + 2f)
					{
						continue;
					}
					float num4 = (job.box ? volume.CarveBox(job.bpos, job.bax, job.bay, job.baz, job.bhalf * volume.carveScale, job.seed, dirty) : volume.Carve(job.pos, num3, job.seed, dirty));
					if (!(num4 <= 0f))
					{
						num += num4 * volume.voxelSize * volume.voxelSize * volume.voxelSize;
						if (volume.renderable && num4 > num2)
						{
							num2 = num4;
							voxelVolume = volume;
						}
					}
				}
				List<ChunkResult> results = TakeResultList();
				foreach (long item in dirty)
				{
					int num5 = VoxelVolume.UnpackSigned(item >> 42);
					int num6 = VoxelVolume.UnpackSigned(item >> 21);
					int num7 = VoxelVolume.UnpackSigned(item);
					foreach (VoxelVolume volume2 in job.volumes)
					{
						if (num5 >= volume2.cMinX && num5 <= volume2.cMaxX && num6 >= volume2.cMinY && num6 <= volume2.cMaxY && num7 >= volume2.cMinZ && num7 <= volume2.cMaxZ && volume2.chunks.TryGetValue(item, out var value) && value.density != null)
						{
							results.Add(TakeResult(volume2, value, item, BuildFineChunkData(volume2, value, item)));
						}
					}
				}
				List<long> dirtyList = TakeKeyList();
				dirtyList.AddRange(dirty);
				float m3Final = num;
				VoxelVolume debrisFinal = voxelVolume;
				MainThread.Post(delegate
				{
					OnCarveJobDone(job, dirtyList, results, m3Final, debrisFinal);
				});
			}

			private static ChunkResult TakeResult(VoxelVolume vol, VoxelChunk chunk, long key, ChunkMeshData data)
			{
				if (resultPool.TryTake(out var result))
				{
					Interlocked.Decrement(ref pooledResults);
				}
				else
				{
					result = new ChunkResult();
				}
				result.vol = vol;
				result.chunk = chunk;
				result.key = key;
				result.data = data;
				return result;
			}

			internal static void ReturnResult(ChunkResult res)
			{
				res.vol = null;
				res.chunk = null;
				res.data = null;
				if (Interlocked.Increment(ref pooledResults) > 256)
				{
					Interlocked.Decrement(ref pooledResults);
				}
				else
				{
					resultPool.Add(res);
				}
			}

			private static List<ChunkResult> TakeResultList()
			{
				if (!resultListPool.TryTake(out var result))
				{
					return new List<ChunkResult>();
				}
				return result;
			}

			private static List<long> TakeKeyList()
			{
				if (!keyListPool.TryTake(out var result))
				{
					return new List<long>();
				}
				return result;
			}

			internal static void ReturnLists(List<long> dirtyKeys, List<ChunkResult> results)
			{
				dirtyKeys.Clear();
				results.Clear();
				keyListPool.Add(dirtyKeys);
				resultListPool.Add(results);
			}

			internal static void DropPools()
			{
				ChunkResult result;
				while (resultPool.TryTake(out result))
				{
					Interlocked.Decrement(ref pooledResults);
				}
				List<ChunkResult> result2;
				while (resultListPool.TryTake(out result2))
				{
				}
				List<long> result3;
				while (keyListPool.TryTake(out result3))
				{
				}
			}

			private static ChunkMeshData BuildFineChunkData(VoxelVolume vol, VoxelChunk chunk, long key)
			{
				return VoxelTerrainManager.BuildFineChunkData(vol, chunk, key, wPos, wNrm, wIdx, pooled: true);
			}
		}

		private class MeshJob
		{
			public List<FineItem> fine;

			public List<VoxelGroup> groups;

			public Dictionary<VoxelVolume, Dictionary<long, VoxelGroup>> lookup;

			public List<VoxelGroup> supers;

			public Dictionary<VoxelVolume, Dictionary<long, VoxelGroup>> superLookup;
		}

		private enum State
		{
			Idle,
			WaitingForHost,
			Converting,
			Baking,
			Ready
		}

		internal class HostConfigData
		{
			public bool valid;

			public int stageKey;

			public string version = "";

			public bool enabled;

			public float voxelSize;

			public float minTerrainSize;

			public float maxCarveRadius;

			public string excludedNames = "";

			public float bloodAmount = 1f;
		}

		internal class ChunkMeshData
		{
			public List<Vector3> positions;

			public List<Vector3> normals;

			public List<int> indices;

			public List<Vector2> uv0;

			public List<Vector2> uv2;

			public List<Color> colors;

			public List<int>[] subIndices;

			public List<int> indicesStore;

			public List<Vector2> uv0Store;

			public List<Vector2> uv2Store;

			public List<Color> colorsStore;

			public int[] triStore;

			public List<int>[] subStore;

			public UvProjection uvProj;
		}

		internal class ChunkResult
		{
			public VoxelVolume vol;

			public VoxelChunk chunk;

			public long key;

			public ChunkMeshData data;
		}

		private class FineItem
		{
			public VoxelVolume vol;

			public VoxelChunk chunk;

			public long key;

			public ChunkMeshData data;
		}

		private class VoxelGroup
		{
			public VoxelVolume vol;

			public int gx;

			public int gy;

			public int gz;

			public int step = 2;

			public VoxelGroup parentSuper;

			public readonly List<VoxelChunk> members = new List<VoxelChunk>();

			public int[] srcTrisUnion;

			public ChunkMeshData coarseData;

			public GameObject go;

			public Mesh mesh;

			public MeshFilter filter;

			public MeshRenderer renderer;

			public bool coarseHasSurface;

			public bool showingCoarse;

			public bool lastShowFine = true;

			public bool carved;

			public Vector3 centerWS;

			public ChunkMeshData colData;

			public Mesh colMesh;

			public GameObject colGo;

			public MeshCollider colCollider;

			public bool fineCollision;
		}

		internal class UvProjection
		{
			public List<Vector2> uv0;

			public List<Vector2> uv2;

			public List<Color> col;

			public int[] tri;
		}

		private static readonly Dictionary<uint, float> gougeRequestLast = new Dictionary<uint, float>();

		private const float GougeRequestWindow = 0.1f;

		private static float gougeGlobalWindowStart;

		private static int gougeGlobalCount;

		private const int GougeGlobalMax = 10;

		private static List<BakeItem> bakeBatch = new List<BakeItem>();

		private static readonly ConcurrentBag<List<BakeItem>> bakeBatchPool = new ConcurrentBag<List<BakeItem>>();

		private static float nextBakeWarn;

		private const float OpenMeshShellRatio = 0.08f;

		private static State state = State.Idle;

		private static int epoch;

		private static int convertedStageId;

		private static List<VoxelVolume> volumes;

		private static List<SourceMesh> sources;

		private static GameObject root;

		private static uint stageSeed;

		private static int carveCounter;

		private static float convertStart;

		private static int lodFrameCounter;

		private static bool teleporterDumped;

		private static readonly Queue<(Vector3 pos, float r, uint attacker)> preReadyCarves = new Queue<(Vector3, float, uint)>();

		private static readonly Dictionary<VoxelChunk, ChunkResult> pendingUploads = new Dictionary<VoxelChunk, ChunkResult>();

		private static readonly List<VoxelChunk> uploadScratch = new List<VoxelChunk>();

		internal static readonly HostConfigData HostConfig = new HostConfigData();

		private static float hostConfigDeadline;

		private static bool versionMismatchWarned;

		private static List<VoxelGroup> groups;

		private static Dictionary<VoxelVolume, Dictionary<long, VoxelGroup>> groupLookup;

		private static List<VoxelGroup> superGroups;

		private static Dictionary<VoxelVolume, Dictionary<long, VoxelGroup>> superLookup;

		private const float SuperLodMult = 2.5f;

		private static List<FineItem> fineItems;

		private static List<int> bakeIds;

		private const float MaxTerrainSize = 2500f;

		private static long baselineNative;

		private static long baselineMono;

		private static Dictionary<long, int> edgeScratch;

		private static Dictionary<Vector3, int> weldScratch;

		private static Vector3[] gatheredGroundNodes;

		private static readonly long UploadBudgetTicks = Stopwatch.Frequency * 6 / 1000;

		private static int CurrentEpoch => Volatile.Read(in epoch);

		internal static List<VoxelVolume> VolumesForStains => volumes;

		private static bool IsRemoteClient
		{
			get
			{
				if (NetworkClient.active)
				{
					return !NetworkServer.active;
				}
				return false;
			}
		}

		private static bool UseHostConfig
		{
			get
			{
				if (IsRemoteClient && HostConfig.valid)
				{
					return HostConfig.stageKey == StageKey();
				}
				return false;
			}
		}

		private static float EffVoxelSize
		{
			get
			{
				if (!UseHostConfig)
				{
					return ModOptions.VoxelSize.Value;
				}
				return HostConfig.voxelSize;
			}
		}

		private static float EffMinTerrainSize
		{
			get
			{
				if (!UseHostConfig)
				{
					return ModOptions.MinTerrainSize.Value;
				}
				return HostConfig.minTerrainSize;
			}
		}

		private static float EffMaxCarveRadius
		{
			get
			{
				if (!UseHostConfig)
				{
					return ModOptions.MaxCarveRadius.Value;
				}
				return HostConfig.maxCarveRadius;
			}
		}

		private static string EffExcludedNames
		{
			get
			{
				if (!UseHostConfig)
				{
					return ModOptions.ExcludedNames.Value;
				}
				return HostConfig.excludedNames;
			}
		}

		internal static float EffBloodAmount
		{
			get
			{
				if (!UseHostConfig)
				{
					return ModOptions.BloodAmount.Value;
				}
				return HostConfig.bloodAmount;
			}
		}

		internal static bool LocalConversionDone => state == State.Ready;

		internal static uint StageSeed => stageSeed;

		public static void RequestCarve(Vector3 pos, float r, uint attackerUserId = 0u)
		{
			//IL_0000: 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_0031: 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)
			GoreSystem.OnWorldCarve(pos, r);
			if (state != State.Ready)
			{
				if (state != State.Idle)
				{
					preReadyCarves.Enqueue((pos, r, attackerUserId));
				}
			}
			else
			{
				EnqueueCarveJob(pos, r, attackerUserId);
				NodeGraphAdjuster.QueueAdjust(pos, r);
			}
		}

		private static void EnqueueCarveJob(Vector3 pos, float r, uint attacker)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			uint seed = stageSeed + (uint)carveCounter++;
			CarveWorker.Enqueue(new CarveWorker.Job
			{
				epoch = epoch,
				volumes = volumes,
				pos = pos,
				r = r,
				seed = seed,
				attacker = attacker,
				maxCarveRadius = EffMaxCarveRadius
			});
		}

		public static void RequestGouge(Vector3 pos, Quaternion rot, Vector3 half, uint attackerUserId = 0u)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)
			GoreSystem.OnWorldGouge(pos, rot, half);
			if (state == State.Ready)
			{
				uint seed = GougeSeed(pos, half);
				CarveWorker.Enqueue(new CarveWorker.Job
				{
					epoch = epoch,
					volumes = volumes,
					box = true,
					bpos = pos,
					bax = rot * Vector3.right,
					bay = rot * Vector3.up,
					baz = rot * Vector3.forward,
					bhalf = half,
					pos = pos,
					r = ((Vector3)(ref half)).magnitude,
					seed = seed,
					attacker = attackerUserId,
					maxCarveRadius = EffMaxCarveRadius
				});
			}
		}

		public static void OnGougeRequest(Vector3 pos, Quaternion rot, Vector3 half, uint attackerUserId)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_0070: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: 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_0147: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || !ModOptions.Enabled.Value || !ModOptions.MeleeCarving.Value || state != State.Ready || !GoreSystem.Finite(pos) || !GoreSystem.Finite(half) || !float.IsFinite(rot.x) || !float.IsFinite(rot.y) || !float.IsFinite(rot.z) || !float.IsFinite(rot.w))
			{
				return;
			}
			rot = Quaternion.Normalize(rot);
			((Vector3)(ref half))..ctor(Mathf.Clamp(half.x, 0.05f, 4f), Mathf.Clamp(half.y, 0.05f, 4f), Mathf.Clamp(half.z, 0.05f, 4f));
			if (IsConnectedUser(attackerUserId))
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (realtimeSinceStartup - gougeGlobalWindowStart >= 0.1f)
				{
					gougeGlobalWindowStart = realtimeSinceStartup;
					gougeGlobalCount = 0;
				}
				if (gougeGlobalCount < 10 && (!gougeRequestLast.TryGetValue(attackerUserId, out var value) || !(realtimeSinceStartup - value < 0.1f)) && (gougeRequestLast.Count <= 64 || gougeRequestLast.ContainsKey(attackerUserId)))
				{
					gougeRequestLast[attackerUserId] = realtimeSinceStartup;
					gougeGlobalCount++;
					RequestGouge(pos, rot, half, attackerUserId);
					NetMessageExtensions.Send((INetMessage)(object)new GougeMessage(pos, rot, half), (NetworkDestination)1);
				}
			}
		}

		private static bool IsConnectedUser(uint netId)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (netId == 0)
			{
				return false;
			}
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null)
				{
					NetworkInstanceId netId2 = ((NetworkBehaviour)readOnlyInstances).netId;
					if (((NetworkInstanceId)(ref netId2)).Value == netId)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static uint GougeSeed(Vector3 pos, Vector3 half)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(pos.x * 8f);
			int num2 = Mathf.RoundToInt(pos.y * 8f);
			int num3 = Mathf.RoundToInt(pos.z * 8f);
			int num4 = (num * 73856093) ^ (num2 * 19349663) ^ (num3 * 83492791) ^ Mathf.RoundToInt((half.x + half.y + half.z) * 32f);
			int num5 = (num4 ^ (num4 >>> 13)) * -2048144789;
			return (uint)(num5 ^ (num5 >>> 16)) + stageSeed;
		}

		private static void OnCarveJobDone(CarveWorker.Job job, List<long> dirtyKeys, List<ChunkResult> results, float m3, VoxelVolume debrisVol)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (job.epoch != epoch || state != State.Ready)
			{
				foreach (ChunkResult result in results)
				{
					if (result.data != null)
					{
						ChunkMeshDataPool.Return(result.data);
					}
					CarveWorker.ReturnResult(result);
				}
				CarveWorker.ReturnLists(dirtyKeys, results);
				return;
			}
			RetireCarvedGroups(dirtyKeys);
			if (m3 > 0.01f)
			{
				if (StageSyncCoordinator.IsServer)
				{
					CarveStats.Add(job.attacker, m3);
					CarveStats.AddMaterial(job.attacker, CarveClass.Of(debrisVol?.material), m3);
				}
				if (debrisVol != null && !job.box)
				{
					DebrisSystem.SpawnBurst(job.pos, job.r, debrisVol.material, m3);
				}
			}
			foreach (ChunkResult result2 in results)
			{
				if (pendingUploads.TryGetValue(result2.chunk, out var value))
				{
					if (value.data != null)
					{
						ChunkMeshDataPool.Return(value.data);
					}
					CarveWorker.ReturnResult(value);
				}
				pendingUploads[result2.chunk] = result2;
			}
			CarveWorker.ReturnLists(dirtyKeys, results);
		}

		private static void RetireCarvedGroups(List<long> dirtyKeys)
		{
			HashSet<long> hashSet = null;
			List<(VoxelVolume, VoxelChunk, long)> list = null;
			foreach (long dirtyKey in dirtyKeys)
			{
				int num = VoxelVolume.UnpackSigned(dirtyKey >> 42) >> 1;
				int num2 = VoxelVolume.UnpackSigned(dirtyKey >> 21) >> 1;
				int num3 = VoxelVolume.UnpackSigned(dirtyKey) >> 1;
				long key = VoxelVolume.PackKey(num, num2, num3);
				foreach (VoxelVolume volume in volumes)
				{
					if (num < volume.gMinX || num > volume.gMaxX || num2 < volume.gMinY || num2 > volume.gMaxY || num3 < volume.gMinZ || num3 > volume.gMaxZ || !groupLookup[volume].TryGetValue(key, out var value) || value.carved)
					{
						continue;
					}
					value.carved = true;
					if (!value.fineCollision)
					{
						value.fineCollision = true;
						if (hashSet == null)
						{
							hashSet = new HashSet<long>(dirtyKeys);
						}
						foreach (VoxelChunk member in value.members)
						{
							long num4 = VoxelVolume.PackKey(member.cx, member.cy, member.cz);
							if (!hashSet.Contains(num4))
							{
								(list ?? (list = new List<(VoxelVolume, VoxelChunk, long)>())).Add((volume, member, num4));
							}
						}
					}
					if (value.showingCoarse)
					{
						value.showingCoarse = false;
						if ((Object)(object)value.renderer != (Object)null)
						{
							((Renderer)value.renderer).enabled = false;
						}
						foreach (VoxelChunk member2 in value.members)
						{
							if ((Object)(object)member2.renderer != (Object)null)
							{
								((Renderer)member2.renderer).enabled = member2.hasSurface;
							}
						}
						value.lastShowFine = true;
					}
					VoxelGroup parentSuper = value.parentSuper;
					if (parentSuper == null || parentSuper.carved)
					{
						continue;
					}
					parentSuper.carved = true;
					if (!parentSuper.showingCoarse)
					{
						continue;
					}
					parentSuper.showingCoarse = false;
					if ((Object)(object)parentSuper.renderer != (Object)null)
					{
						((Renderer)parentSuper.renderer).enabled = false;
					}
					foreach (VoxelChunk member3 in parentSuper.members)
					{
						if ((Object)(object)member3.renderer != (Object)null)
						{
							((Renderer)member3.renderer).enabled = member3.hasSurface;
						}
					}
				}
			}
			if (list != null)
			{
				CarveWorker.Enqueue(new CarveWorker.Job
				{
					epoch = epoch,
					volumes = volumes,
					rebuild = list,
					maxCarveRadius = EffMaxCarveRadius
				});
			}
		}

		private static void ApplyChunkResult(ChunkResult res)
		{
			//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_0126: Expected O, but got Unknown
			VoxelChunk chunk = res.chunk;
			VoxelVolume vol = res.vol;
			if (res.data == null)
			{
				chunk.hasSurface = false;
				if ((Object)(object)chunk.go != (Object)null)
				{
					if ((Object)(object)chunk.mesh != (Object)null)
					{
						if (chunk.mesh.isReadable)
						{
							chunk.mesh.Clear();
						}
						else
						{
							Object.Destroy((Object)(object)chunk.mesh);
							chunk.mesh = null;
							if ((Object)(object)chunk.filter != (Object)null)
							{
								chunk.filter.sharedMesh = null;
							}
						}
					}
					if ((Object)(object)chunk.renderer != (Object)null)
					{
						((Renderer)chunk.renderer).enabled = false;
					}
					if ((Object)(object)chunk.collider != (Object)null)
					{
						((Collider)chunk.collider).enabled = false;
					}
				}
				TryRetireGroupCollider(vol, chunk);
				return;
			}
			if ((Object)(object)chunk.mesh != (Object)null && !chunk.mesh.isReadable)
			{
				Object.Destroy((Object)(object)chunk.mesh);
				chunk.mesh = null;
			}
			if ((Object)(object)chunk.go != (Object)null && (Object)(object)chunk.mesh == (Object)null)
			{
				chunk.mesh = new Mesh
				{
					name = ((Object)chunk.go).name
				};
				if ((Object)(object)chunk.filter != (Object)null)
				{
					chunk.filter.sharedMesh = chunk.mesh;
				}
			}
			if ((Object)(object)chunk.mesh != (Object)null)
			{
				chunk.mesh.MarkDynamic();
			}
			UploadFineMesh(vol, chunk, res.data);
			ChunkMeshDataPool.Return(res.data);
			res.data = null;
			if ((Object)(object)chunk.collider == (Object)null && (Object)(object)chunk.go != (Object)null)
			{
				chunk.collider = chunk.go.AddComponent<MeshCollider>();
			}
			((Collider)chunk.collider).enabled = true;
			if ((Object)(object)chunk.collider.sharedMesh == (Object)null && !GroupHasCoarseCollider(vol, chunk))
			{
				try
				{
					Physics.BakeMesh(((Object)chunk.mesh).GetInstanceID(), false);
				}
				catch (Exception e)
				{
					WarnBakeFailed(e);
				}
				chunk.collider.sharedMesh = chunk.mesh;
			}
			else
			{
				chunk.bakeInFlight = true;
				bakeBatch.Add(new BakeItem
				{
					chunk = chunk,
					vol = vol,
					meshId = ((Object)chunk.mesh).GetInstanceID()
				});
			}
		}

		private static void FlushColliderBakes()
		{
			if (bakeBatch.Count == 0)
			{
				return;
			}
			List<BakeItem> batch = bakeBatch;
			bakeBatch = (bakeBatchPool.TryTake(out var result) ? result : new List<BakeItem>());
			int myEpoch = epoch;
			Task.Run(delegate
			{
				foreach (BakeItem item in batch)
				{
					try
					{
						Physics.BakeMesh(item.meshId, false);
					}
					catch (Exception e)
					{
						WarnBakeFailed(e);
					}
				}
				MainThread.Post(delegate
				{
					foreach (BakeItem item2 in batch)
					{
						VoxelChunk chunk = item2.chunk;
						chunk.bakeInFlight = false;
						if (epoch == myEpoch && !((Object)(object)chunk.go == (Object)null) && !((Object)(object)chunk.collider == (Object)null) && chunk.hasSurface)
						{
							chunk.collider.sharedMesh = null;
							chunk.collider.sharedMesh = chunk.mesh;
							TryRetireGroupCollider(item2.vol, chunk);
						}
					}
					batch.Clear();
					bakeBatchPool.Add(batch);
				});
			});
		}

		private static void TryRetireGroupCollider(VoxelVolume vol, VoxelChunk chunk)
		{
			if (groupLookup == null || !groupLookup.TryGetValue(vol, out var value))
			{
				return;
			}
			long key = GroupKeyOf(chunk.cx, chunk.cy, chunk.cz);
			if (!value.TryGetValue(key, out var value2) || !value2.fineCollision || (Object)(object)value2.colCollider == (Object)null)
			{
				return;
			}
			foreach (VoxelChunk member in value2.members)
			{
				if (member.hasSurface && ((Object)(object)member.collider == (Object)null || member.bakeInFlight || (Object)(object)member.collider.sharedMesh == (Object)null))
				{
					return;
				}
			}
			Object.Destroy((Object)(object)value2.colGo);
			value2.colGo = null;
			value2.colCollider = null;
			Object.Destroy((Object)(object)value2.colMesh);
			value2.colMesh = null;
		}

		private static bool GroupHasCoarseCollider(VoxelVolume vol, VoxelChunk chunk)
		{
			if (groupLookup == null || !groupLookup.TryGetValue(vol, out var value))
			{
				return false;
			}
			long key = GroupKeyOf(chunk.cx, chunk.cy, chunk.cz);
			if (value.TryGetValue(key, out var value2))
			{
				return (Object)(object)value2.colCollider != (Object)null;
			}
			return false;
		}

		private static void WarnBakeFailed(Exception e)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup < nextBakeWarn))
			{
				nextBakeWarn = realtimeSinceStartup + 5f;
				ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] collider bake failed (collider keeps its old shape): " + e.Message));
			}
		}

		private static void BeginConversion()
		{
			convertStart = Time.realtimeSinceStartup;
			sources = GatherSources();
			if (sources.Count == 0)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] no convertible terrain on this stage (non-readable meshes?), staying vanilla");
				StayVanilla();
				return;
			}
			Material val = null;
			long num = -1L;
			foreach (SourceMesh source in sources)
			{
				if (source.hasVisibleRenderer && (Object)(object)source.material != (Object)null && source.TriCount > num)
				{
					num = source.TriCount;
					val = source.material;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] no visible source material found, staying vanilla");
				StayVanilla();
				return;
			}
			foreach (SourceMesh source2 in sources)
			{
				if (source2.hasVisibleRenderer && (Object)(object)source2.material == (Object)null)
				{
					source2.material = val;
				}
			}
			foreach (SourceMesh source3 in sources)
			{
				if (!source3.hasVisibleRenderer)
				{
					continue;
				}
				if (source3.materials == null || source3.materials.Length == 0)
				{
					source3.materials = (Material[])(object)new Material[1] { source3.material };
					continue;
				}
				for (int i = 0; i < source3.materials.Length; i++)
				{
					if ((Object)(object)source3.materials[i] == (Object)null)
					{
						source3.materials[i] = source3.material;
					}
				}
			}
			long num2 = 0L;
			foreach (SourceMesh source4 in sources)
			{
				num2 += source4.TriCount;
			}
			if (ModOptions.VerboseLogging.Value)
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] converting {sources.Count} meshes, {num2} tris, voxel {EffVoxelSize}m");
			}
			StageSyncCoordinator.FreezeForLoading();
			ConvertProgress.Set("preparing", 0);
			StageSyncCoordinator.OnConversionBegin();
			state = State.Converting;
			int myEpoch = epoch;
			List<SourceMesh> srcs = sources;
			float voxelSize = EffVoxelSize;
			Vector3[] groundNodes = gatheredGroundNodes;
			gatheredGroundNodes = null;
			Task.Run(delegate
			{
				try
				{
					OrientSources(srcs, groundNodes, () => CurrentEpoch != myEpoch);
					if (CurrentEpoch == myEpoch)
					{
						List<VoxelVolume> vols = MeshVoxelizer.Build(srcs, voxelSize, () => CurrentEpoch != myEpoch);
						if (CurrentEpoch == myEpoch)
						{
							MeshJob job = BuildMeshStructure(vols, () => CurrentEpoch != myEpoch);
							if (CurrentEpoch == myEpoch)
							{
								int fineN = job.fine.Count;
								int groupN = job.groups.Count;
								int superN = job.supers.Count;
								int totalItems = fineN + groupN + superN + groupN;
								PostAndWait(myEpoch, delegate
								{
									//IL_0060: Unknown result type (might be due to invalid IL or missing references)
									//IL_006a: Expected O, but got Unknown
									volumes = vols;
									groups = job.groups;
									groupLookup = job.lookup;
									superGroups = job.supers;
									superLookup = job.superLookup;
									fineItems = job.fine;
									root = new GameObject("ScorchedVoxelsRoot");
									ConvertProgress.Set("building meshes", totalItems);
								});
								if (CurrentEpoch == myEpoch)
								{
									int num3 = 0;
									for (int num4 = 0; num4 < totalItems; num4 += 2000)
									{
										if (CurrentEpoch != myEpoch)
										{
											return;
										}
										int num5 = Math.Min(num4 + 2000, totalItems);
										BuildWaveGeometry(job, num4, num5, fineN, groupN, () => CurrentEpoch != myEpoch);
										if (CurrentEpoch != myEpoch)
										{
											return;
										}
										int s = num4;
										int e = num5;
										PostAndWait(myEpoch, delegate
										{
											//IL_0181: Unknown result type (might be due to invalid IL or missing references)
											//IL_0188: Expected O, but got Unknown
											//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
											for (int j = s; j < e; j++)
											{
												if (j < fineN)
												{
													FineItem fineItem = job.fine[j];
													if (fineItem.data != null)
													{
														UploadFineMesh(fineItem.vol, fineItem.chunk, fineItem.data);
														fineItem.data = null;
													}
												}
												else if (j < fineN + groupN)
												{
													VoxelGroup voxelGroup = job.groups[j - fineN];
													if (voxelGroup.coarseData != null)
													{
														UploadGroupMesh(voxelGroup, voxelGroup.coarseData);
														voxelGroup.coarseData = null;
													}
												}
												else if (j < fineN + groupN + superN)
												{
													VoxelGroup voxelGroup2 = job.supers[j - fineN - groupN];
													if (voxelGroup2.coarseData != null)
													{
														UploadGroupMesh(voxelGroup2, voxelGroup2.coarseData);
														voxelGroup2.coarseData = null;
													}
												}
												else
												{
													VoxelGroup voxelGroup3 = job.groups[j - fineN - groupN - superN];
													if (voxelGroup3.colData != null)
													{
														Mesh val2 = new Mesh();
														((Object)val2).name = $"voxcol{voxelGroup3.vol.index}_{voxelGroup3.gx}_{voxelGroup3.gy}_{voxelGroup3.gz}";
														voxelGroup3.colMesh = val2;
														FillMesh(voxelGroup3.colMesh, voxelGroup3.colData, CollisionMeshBounds(voxelGroup3));
														ChunkMeshDataPool.Return(voxelGroup3.colData);
														voxelGroup3.colData = null;
													}
												}
											}
										});
										if (++num3 % 6 == 0)
										{
											GC.Collect();
										}
									}
									if (CurrentEpoch == myEpoch)
									{
										GC.Collect();
										PostAndWait(myEpoch, delegate
										{
											BeginBake();
										});
									}
								}
							}
						}
					}
				}
				catch (Exception arg)
				{
					ScorchedVoxelsPlugin.Log.LogError((object)$"[ScorchedVoxels] conversion failed, staying vanilla: {arg}");
					MainThread.Post(delegate
					{
						if (epoch == myEpoch)
						{
							FailToVanilla();
						}
					});
				}
			});
		}

		private static MeshJob BuildMeshStructure(List<VoxelVolume> vols, Func<bool> isCancelled)
		{
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: 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_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			MeshJob meshJob = new MeshJob
			{
				fine = new List<FineItem>(),
				groups = new List<VoxelGroup>(),
				lookup = new Dictionary<VoxelVolume, Dictionary<long, VoxelGroup>>(),
				supers = new List<VoxelGroup>(),
				superLookup = new Dictionary<VoxelVolume, Dictionary<long, VoxelGroup>>()
			};
			foreach (VoxelVolume vol in vols)
			{
				Dictionary<long, VoxelGroup> value = new Dictionary<long, VoxelGroup>();
				meshJob.lookup[vol] = value;
				meshJob.superLookup[vol] = new Dictionary<long, VoxelGroup>();
				foreach (KeyValuePair<long, VoxelChunk> chunk in vol.chunks)
				{
					VoxelChunk value2 = chunk.Value;
					meshJob.fine.Add(new FineItem
					{
						vol = vol,
						chunk = value2,
						key = chunk.Key
					});
					int num = value2.cx >> 1;
					int num2 = value2.cy >> 1;
					int num3 = value2.cz >> 1;
					if (num < vol.gMinX)
					{
						vol.gMinX = num;
					}
					if (num > vol.gMaxX)
					{
						vol.gMaxX = num;
					}
					if (num2 < vol.gMinY)
					{
						vol.gMinY = num2;
					}
					if (num2 > vol.gMaxY)
					{
						vol.gMaxY = num2;
					}
					if (num3 < vol.gMinZ)
					{
						vol.gMinZ = num3;
					}
					if (num3 > vol.gMaxZ)
					{
						vol.gMaxZ = num3;
					}
					VoxelGroup orCreateGroup = GetOrCreateGroup(meshJob, vol, value2);
					orCreateGroup.members.Add(value2);
					if (vol.renderable)
					{
						VoxelGroup orCreateSuper = GetOrCreateSuper(meshJob, vol, value2);
						orCreateSuper.members.Add(value2);
						orCreateGroup.parentSuper = orCreateSuper;
					}
				}
			}
			foreach (VoxelVolume vol2 in vols)
			{
				float num4 = 48f * vol2.voxelSize;
				Vector3 min = ((Bounds)(ref vol2.boundsWS)).min;
				Vector3 max = ((Bounds)(ref vol2.boundsWS)).max;
				List<VoxelVolume> list = null;
				foreach (VoxelVolume vol3 in vols)
				{
					if (vol3 != vol2 && VisiblySolid(vol3) && Outranks(vol3, vol2))
					{
						Vector3 min2 = ((Bounds)(ref vol3.boundsWS)).min;
						Vector3 max2 = ((Bounds)(ref vol3.boundsWS)).max;
						if (!(min2.x > max.x + num4) && !(max2.x < min.x - num4) && !(min2.y > max.y + num4) && !(max2.y < min.y - num4) && !(min2.z > max.z + num4) && !(max2.z < min.z - num4))
						{
							(list ?? (list = new List<VoxelVolume>(4))).Add(vol3);
						}
					}
				}
				vol2.rivalCandidates = list;
			}
			HashSet<int> triSet = new HashSet<int>();
			BuildUnion(meshJob.groups);
			BuildUnion(meshJob.supers);
			return meshJob;
			void BuildUnion(List<VoxelGroup> list2)
			{
				foreach (VoxelGroup item2 in list2)
				{
					if (item2.vol.renderable)
					{
						triSet.Clear();
						foreach (VoxelChunk member in item2.members)
						{
							if (member.srcTris != null)
							{
								int[] srcTris = member.srcTris;
								foreach (int item in srcTris)
								{
									triSet.Add(item);
								}
							}
						}
						if (triSet.Count > 0)
						{
							item2.srcTrisUnion = new int[triSet.Count];
							triSet.CopyTo(item2.srcTrisUnion);
						}
					}
				}
			}
		}

		private static void BuildWaveGeometry(MeshJob job, int start, int end, int fineN, int groupN, Func<bool> isCancelled)
		{
			int superN = job.supers.Count;
			int num = Mathf.Clamp(Environment.ProcessorCount - 2, 1, 14);
			Task[] array = new Task[num];
			int cursor = start - 1;
			for (int i = 0; i < num; i++)
			{
				array[i] = Task.Run(delegate
				{
					List<Vector3> pos = new List<Vector3>();
					List<Vector3> nrm = new List<Vector3>();
					List<int> idx = new List<int>();
					Dictionary<long, bool> blockCache = new Dictionary<long, bool>();
					while (true)
					{
						int num2 = Interlocked.Increment(ref cursor);
						if (num2 >= end || isCancelled())
						{
							break;
						}
						if (num2 < fineN)
						{
							BuildFineData(job.fine[num2], pos, nrm, idx);
						}
						else if (num2 < fineN + groupN)
						{
							BuildCoarseData(job.groups[num2 - fineN], pos, nrm, idx);
						}
						else if (num2 < fineN + groupN + superN)
						{
							BuildCoarseData(job.supers[num2 - fineN - groupN], pos, nrm, idx);
						}
						else
						{
							BuildCollisionData(job.groups[num2 - fineN - groupN - superN], pos, nrm, idx, blockCache);
						}
						Interlocked.Increment(ref ConvertProgress.Done);
					}
				});
			}
			Task.WaitAll(array);
		}

		private static void BuildFineData(FineItem f, List<Vector3> pos, List<Vector3> nrm, List<int> idx)
		{
			f.data = BuildFineChunkData(f.vol, f.chunk, f.key, pos, nrm, idx, pooled: false);
		}

		private static void BuildCoarseData(VoxelGroup g, List<Vector3> pos, List<Vector3> nrm, List<int> idx)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (g.vol.renderable)
			{
				int num = g.gx * 16 * g.step;
				int num2 = g.gy * 16 * g.step;
				int num3 = g.gz * 16 * g.step;
				if (SurfaceNets.Build(g.vol, num, num2, num3, g.step, null, GroupRivals(g), pos, nrm, idx))
				{
					UvProjection uvProjection = ProjectUvs(g.vol, g.srcTrisUnion, new Vector3((float)num, (float)num2, (float)num3) * g.vol.voxelSize, pos);
					List<int>[] array = SplitBySubmesh(g.vol, uvProjection?.tri, idx);
					g.coarseData = new ChunkMeshData
					{
						positions = new List<Vector3>(pos),
						normals = new List<Vector3>(nrm),
						indices = ((array == null) ? new List<int>(idx) : null),
						uv0 = uvProjection?.uv0,
						uv2 = uvProjection?.uv2,
						colors = uvProjection?.col,
						subIndices = array
					};
				}
				g.srcTrisUnion = null;
			}
		}

		private static void BuildCollisionData(VoxelGroup g, List<Vector3> pos, List<Vector3> nrm, List<int> idx, Dictionary<long, bool> blockCache)
		{
			if (!ModOptions.CoarseCollision.Value)
			{
				g.fineCollision = true;
				return;
			}
			blockCache.Clear();
			VoxelVolume vol = g.vol;
			foreach (VoxelChunk member in g.members)
			{
				byte[] density = member.density;
				if (density == null)
				{
					continue;
				}
				int num = member.cx * 16;
				int num2 = member.cy * 16;
				int num3 = member.cz * 16;
				for (int i = 0; i < 16; i++)
				{
					for (int j = 0; j < 16; j++)
					{
						for (int k = 0; k < 16; k++)
						{
							if (!((float)(int)density[VoxelVolume.VoxelIndex(k, i, j)] < 127.5f) && (k == 0 || (float)(int)density[VoxelVolume.VoxelIndex(k - 1, i, j)] < 127.5f || k == 15 || (float)(int)density[VoxelVolume.VoxelIndex(k + 1, i, j)] < 127.5f || i == 0 || (float)(int)density[VoxelVolume.VoxelIndex(k, i - 1, j)] < 127.5f || i == 15 || (float)(int)density[VoxelVolume.VoxelIndex(k, i + 1, j)] < 127.5f || j == 0 || (float)(int)density[VoxelVolume.VoxelIndex(k, i, j - 1)] < 127.5f || j == 15 || (float)(int)density[VoxelVolume.VoxelIndex(k, i, j + 1)] < 127.5f))
							{
								int num4 = num + k;
								int num5 = num2 + i;
								int num6 = num3 + j;
								int num7 = num4 >> 1;
								int num8 = num5 >> 1;
								int num9 = num6 >> 1;
								int cx = num7 + (((num4 & 1) != 0) ? 1 : (-1));
								int cy = num8 + (((num5 & 1) != 0) ? 1 : (-1));
								int cz = num9 + (((num6 & 1) != 0) ? 1 : (-1));
								if (!CoarseBlockSolid(vol, num7, num8, num9, blockCache) && !CoarseBlockSolid(vol, cx, num8, num9, blockCache) && !CoarseBlockSolid(vol, num7, cy, num9, blockCache) && !CoarseBlockSolid(vol, cx, cy, num9, blockCache) && !CoarseBlockSolid(vol, num7, num8, cz, blockCache) && !CoarseBlockSolid(vol, cx, num8, cz, blockCache) && !CoarseBlockSolid(vol, num7, cy, cz, blockCache) && !CoarseBlockSolid(vol, cx, cy, cz, blockCache))
								{
									g.fineCollision = true;
									return;
								}
							}
						}
					}
				}
			}
			int ox = g.gx * 16 * 2;
			int oy = g.gy * 16 * 2;
			int oz = g.gz * 16 * 2;
			if (SurfaceNets.Build(g.vol, ox, oy, oz, 2, null, null, pos, nrm, idx, skirts: false, dilate: false))
			{
				ChunkMeshData chunkMeshData = ChunkMeshDataPool.Take();
				chunkMeshData.positions.AddRange(pos);
				chunkMeshData.normals.AddRange(nrm);
				ChunkMeshData chunkMeshData2 = chunkMeshData;
				chunkMeshData.indices = chunkMeshData2.indicesStore ?? (chunkMeshData2.indicesStore = new List<int>());
				chunkMeshData.indices.Clear();
				chunkMeshData.indices.AddRange(idx);
				g.colData = chunkMeshData;
			}
		}

		private static bool CoarseBlockSolid(VoxelVolume vol, int cx, int cy, int cz, Dictionary<long, bool> cache)
		{
			long key = VoxelVolume.PackKey(cx, cy, cz);
			if (cache.TryGetValue(key, out var value))
			{
				return value;
			}
			long lastKey = long.MinValue;
			VoxelChunk lastChunk = null;
			byte lastSolid = 0;
			int num = 0;
			int num2 = cx << 1;
			int num3 = cy << 1;
			int num4 = cz << 1;
			for (int i = 0; i < 2; i++)
			{
				for (int j = 0; j < 2; j++)
				{
					for (int k = 0; k < 2; k++)
					{
						num += vol.SampleCached(num2 + k, num3 + i, num4 + j, ref lastKey, ref lastChunk, ref lastSolid);
					}
				}
			}
			return cache[key] = (float)num / 8f >= 127.5f;
		}

		private static void PostAndWait(int myEpoch, Action action)
		{
			ManualResetEventSlim done = new ManualResetEventSlim(initialState: false);
			try
			{
				MainThread.Post(delegate
				{
					try
					{
						if (epoch == myEpoch)
						{
							action();
						}
					}
					finally
					{
						done.Set();
					}
				});
				done.Wait();
			}
			finally
			{
				if (done != null)
				{
					((IDisposable)done).Dispose();
				}
			}
		}

		private static long GroupKeyOf(int cx, int cy, int cz)
		{
			return VoxelVolume.PackKey(cx >> 1, cy >> 1, cz >> 1);
		}

		private static VoxelGroup MakeGroup(VoxelVolume vol, int gx, int gy, int gz, int step)
		{
			//IL_0042: 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)
			return new VoxelGroup
			{
				vol = vol,
				gx = gx,
				gy = gy,
				gz = gz,
				step = step,
				centerWS = new Vector3((float)gx + 0.5f, (float)gy + 0.5f, (float)gz + 0.5f) * ((float)(16 * step) * vol.voxelSize)
			};
		}

		private static VoxelGroup GetOrCreateGroup(MeshJob job, VoxelVolume vol, VoxelChunk chunk)
		{
			int num = chunk.cx >> 1;
			int num2 = chunk.cy >> 1;
			int num3 = chunk.cz >> 1;
			long key = VoxelVolume.PackKey(num, num2, num3);
			Dictionary<long, VoxelGroup> dictionary = job.lookup[vol];
			if (!dictionary.TryGetValue(key, out var value))
			{
				value = (dictionary[key] = MakeGroup(vol, num, num2, num3, 2));
				job.groups.Add(value);
			}
			return value;
		}

		private static VoxelGroup GetOrCreateSuper(MeshJob job, VoxelVolume vol, VoxelChunk chunk)
		{
			int num = chunk.cx >> 2;
			int num2 = chunk.cy >> 2;
			int num3 = chunk.cz >> 2;
			long key = VoxelVolume.PackKey(num, num2, num3);
			Dictionary<long, VoxelGroup> dictionary = job.superLookup[vol];
			if (!dictionary.TryGetValue(key, out var value))
			{
				value = (dictionary[key] = MakeGroup(vol, num, num2, num3, 4));
				job.supers.Add(value);
			}
			return value;
		}

		internal static bool SolidAtWorld(Vector3 p, bool uncovered)
		{
			//IL_0032: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			List<VoxelVolume> list = volumes;
			if (list == null || list.Count == 0)
			{
				return uncovered;
			}
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				VoxelVolume voxelVolume = list[i];
				if (voxelVolume != null && voxelVolume.chunks != null && !(((Bounds)(ref voxelVolume.meshBoundsWS)).SqrDistance(p) > 0f))
				{
					flag = true;
					int ix = Mathf.FloorToInt(p.x / voxelVolume.voxelSize);
					int iy = Mathf.FloorToInt(p.y / voxelVolume.voxelSize);
					int iz = Mathf.FloorToInt(p.z / voxelVolume.voxelSize);
					if ((float)(int)voxelVolume.Sample(ix, iy, iz) >= 127.5f)
					{
						return true;
					}
				}
			}
			if (!flag)
			{
				return uncovered;
			}
			return false;
		}

		private static int StageKey()
		{
			if (!((Object)(object)Run.instance != (Object)null))
			{
				return -1;
			}
			return Run.instance.stageClearCount;
		}

		public static void Reset()
		{
			epoch++;
			NodeGraphAdjuster.Restore();
			state = State.Idle;
			DestroyStageMeshes();
			volumes = null;
			sources = null;
			groups = null;
			groupLookup = null;
			superGroups = null;
			superLookup = null;
			fineItems = null;
			bakeIds = null;
			if ((Object)(object)root != (Object)null)
			{
				Object.Destroy((Object)(object)root);
			}
			root = null;
			preReadyCarves.Clear();
			gougeRequestLast.Clear();
			foreach (KeyValuePair<VoxelChunk, ChunkResult> pendingUpload in pendingUploads)
			{
				if (pendingUpload.Value.data != null)
				{
					ChunkMeshDataPool.Return(pendingUpload.Value.data);
				}
				CarveWorker.ReturnResult(pendingUpload.Value);
			}
			pendingUploads.Clear();
			convertedStageId = 0;
			carveCounter = 0;
			teleporterDumped = false;
			StageSyncCoordinator.OnStageReset();
			LootReveal.ResetForStage(LootReveal.CurrentStageKey());
			DebrisSystem.Reset();
			GoreSystem.Reset();
			FarewellBlast.Reset();
			StageSyncCoordinator.Unfreeze();
		}

		private static void DestroyStageMeshes()
		{
			if (volumes != null)
			{
				foreach (VoxelVolume volume in volumes)
				{
					VoxelChunk[] array = new VoxelChunk[volume.chunks.Count];
					volume.chunks.Values.CopyTo(array, 0);
					VoxelChunk[] array2 = array;
					foreach (VoxelChunk voxelChunk in array2)
					{
						if ((Object)(object)voxelChunk.mesh != (Object)null)
						{
							Object.Destroy((Object)(object)voxelChunk.mesh);
						}
					}
				}
			}
			if (groups != null)
			{
				foreach (VoxelGroup group in groups)
				{
					if ((Object)(object)group.mesh != (Object)null)
					{
						Object.Destroy((Object)(object)group.mesh);
					}
					if ((Object)(object)group.colMesh != (Object)null)
					{
						Object.Destroy((Object)(object)group.colMesh);
					}
				}
			}
			if (superGroups == null)
			{
				return;
			}
			foreach (VoxelGroup superGroup in superGroups)
			{
				if ((Object)(object)superGroup.mesh != (Object)null)
				{
					Object.Destroy((Object)(object)superGroup.mesh);
				}
			}
		}

		private static void LogMemoryReport()
		{
			if (volumes == null)
			{
				return;
			}
			long num = 0L;
			long num2 = 0L;
			long num3 = 0L;
			long num4 = 0L;
			long num5 = 0L;
			long num6 = 0L;
			long num7 = 0L;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			int num11 = 0;
			foreach (VoxelVolume volume in volumes)
			{
				foreach (KeyValuePair<long, VoxelChunk> chunk in volume.chunks)
				{
					VoxelChunk value = chunk.Value;
					num8++;
					if (value.density != null)
					{
						num += value.density.Length;
					}
					if (value.srcTris != null)
					{
						num2 += (long)value.srcTris.Length * 4L;
					}
					if ((Object)(object)value.collider != (Object)null)
					{
						num10++;
					}
					if ((Object)(object)value.mesh != (Object)null)
					{
						num9++;
						num5 += value.mesh.vertexCount;
						if (value.mesh.isReadable)
						{
							num11++;
						}
						num3 += Profiler.GetRuntimeMemorySizeLong((Object)(object)value.mesh);
						num6 += MeshBufferBytes(value.mesh);
					}
				}
			}
			long num12 = 0L;
			int num13 = 0;
			int num14 = 0;
			if (groups != null)
			{
				foreach (VoxelGroup group in groups)
				{
					if ((Object)(object)group.mesh != (Object)null)
					{
						num4 += Profiler.GetRuntimeMemorySizeLong((Object)(object)group.mesh);
						num7 += MeshBufferBytes(group.mesh);
					}
					if ((Object)(object)group.colMesh != (Object)null)
					{
						num12 += MeshBufferBytes(group.colMesh);
						num13++;
					}
					if (group.fineCollision)
					{
						num14++;
					}
				}
			}
			if (superGroups != null)
			{
				foreach (VoxelGroup superGroup in superGroups)
				{
					if ((Object)(object)superGroup.mesh != (Object)null)
					{
						num4 += Profiler.GetRuntimeMemorySizeLong((Object)(object)superGroup.mesh);
						num7 += MeshBufferBytes(superGroup.mesh);
					}
				}
			}
			long num15 = 0L;
			long num16 = 0L;
			HashSet<SourceMesh> hashSet = new HashSet<SourceMesh>();
			foreach (VoxelVolume volume2 in volumes)
			{
				SourceMesh source = volume2.source;
				if (source != null && hashSet.Add(source))
				{
					if (source.verts != null)
					{
						num15 += (long)source.verts.Length * 12L;
					}
					if (source.indices != null)
					{
						num15 += (long)source.indices.Length * 4L;
					}
					if (source.uv0 != null)
					{
						num15 += (long)source.uv0.Length * 8L;
					}
					if (source.uv2 != null)
					{
						num15 += (long)source.uv2.Length * 8L;
					}
					if (source.colors != null)
					{
						num15 += (long)source.colors.Length * 4L;
					}
					if (source.triCenter != null)
					{
						num15 += (long)source.triCenter.Length * 12L;
					}
					if (source.triRadius != null)
					{
						num15 += (long)source.triRadius.Length * 4L;
					}
					if (source.subOfTri != null)
					{
						num15 += (long)source.subOfTri.Length * 4L;
					}
					if (source.winding != null)
					{
						num16 += source.winding.ApproxBytes;
					}
				}
			}
			long num17 = num + num2 + num15 + num16 + num6 + num7 + num12;
			long allocatedMemoryForGraphicsDriver = Profiler.GetAllocatedMemoryForGraphicsDriver();
			long totalAllocatedMemoryLong = Profiler.GetTotalAllocatedMemoryLong();
			long totalReservedMemoryLong = Profiler.GetTotalReservedMemoryLong();
			long monoUsedSizeLong = Profiler.GetMonoUsedSizeLong();
			long monoHeapSizeLong = Profiler.GetMonoHeapSizeLong();
			GC.Collect();
			GC.WaitForPendingFinalizers();
			GC.Collect();
			long monoUsedSizeLong2 = Profiler.GetMonoUsedSizeLong();
			long monoHeapSizeLong2 = Profiler.GetMonoHeapSizeLong();
			ManualLogSource log = ScorchedVoxelsPlugin.Log;
			log.LogInfo((object)"===== [SV-MEM] ScorchedVoxels memory report =====");
			log.LogInfo((object)$"[SV-MEM] volumes {volumes.Count}, chunks {num8}, surface meshes {num9} ({num11} readable), voxel verts {num5}");
			log.LogInfo((object)$"[SV-MEM] colliders: {num13} coarse GROUP + {num10} fine chunk ({num14} groups on fine: thin/carved)");
			log.LogInfo((object)$"[SV-MEM] fine chunk mesh buffers (vtx+idx; readable = also on CPU): {(double)num6 / 1048576.0,8:F1} MB  (profiler/obj said {(double)num3 / 1048576.0:F1})");
			log.LogInfo((object)$"[SV-MEM] group collision mesh buffers (CPU only, ~1/4 tris)   : {(double)num12 / 1048576.0,8:F1} MB");
			log.LogInfo((object)$"[SV-MEM] LOD + far-LOD coarse mesh buffers (CPU freed)    : {(double)num7 / 1048576.0,8:F1} MB  (profiler/obj said {(double)num4 / 1048576.0:F1})");
			log.LogInfo((object)$"[SV-MEM] density arrays                                   : {(double)num / 1048576.0,8:F1} MB");
			log.LogInfo((object)$"[SV-MEM] per-chunk srcTris / source meshes / winding      : {(double)num2 / 1048576.0:F1} / {(double)num15 / 1048576.0:F1} / {(double)num16 / 1048576.0:F1} MB");
			log.LogInfo((object)$"[SV-MEM] accounted managed+mesh-buffer sum                : {(double)num17 / 1048576.0,8:F1} MB");
			log.LogInfo((object)"[SV-MEM] --- Unity engine totals ---");
			log.LogInfo((object)$"[SV-MEM] GPU / graphics driver (all mesh + texture VRAM)  : {(double)allocatedMemoryForGraphicsDriver / 1048576.0,8:F0} MB");
			log.LogInfo((object)$"[SV-MEM] Unity native used / reserved                     : {(double)totalAllocatedMemoryLong / 1048576.0,8:F0} / {(double)totalReservedMemoryLong / 1048576.0:F0} MB");
			log.LogInfo((object)$"[SV-MEM] Mono managed used / heap                         : {(double)monoUsedSizeLong / 1048576.0,8:F0} / {(double)monoHeapSizeLong / 1048576.0:F0} MB");
			log.LogInfo((object)$"[SV-MEM] Mono managed AFTER full GC (live retained)       : {(double)monoUsedSizeLong2 / 1048576.0,8:F0} MB  (freed {(double)(monoUsedSizeLong - monoUsedSizeLong2) / 1048576.0:F0} MB of garbage)");
			log.LogInfo((object)$"[SV-MEM] Mono HEAP RESERVED after GC (did Boehm return it?): {(double)monoHeapSizeLong2 / 1048576.0,8:F0} MB  (was {(double)monoHeapSizeLong / 1048576.0:F0}; if unchanged, heap is sticky)");
			log.LogInfo((object)"[SV-MEM] --- delta vs stage-start baseline (mod's own cost; trust FIRST stage of a run only) ---");
			log.LogInfo((object)($"[SV-MEM] native {(double)baselineNative / 1048576.0:F0} -> {(double)totalReservedMemoryLong / 1048576.0:F0} (+{(double)(totalReservedMemoryLong - baselineNative) / 1048576.0:F0} MB) | " + $"mono {(double)baselineMono / 1048576.0:F0} -> {(double)monoHeapSizeLong / 1048576.0:F0} (+{(double)(monoHeapSizeLong - baselineMono) / 1048576.0:F0} MB)"));
			log.LogInfo((object)"[SV-MEM] (for whole-process RSS incl. driver + PhysX, check Task Manager alongside this report)");
			log.LogInfo((object)"=================================================");
		}

		private static long MeshBufferBytes(Mesh m)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			long num = 0L;
			int vertexBufferCount = m.vertexBufferCount;
			for (int i = 0; i < vertexBufferCount; i++)
			{
				num += (long)m.GetVertexBufferStride(i) * (long)m.vertexCount;
			}
			int num2 = (((int)m.indexFormat == 0) ? 2 : 4);
			for (int j = 0; j < m.subMeshCount; j++)
			{
				num += m.GetIndexCount(j) * num2;
			}
			return num;
		}

		private static void DumpTeleporterAssets(TeleporterInteraction tp)
		{
			//IL_0023: 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)
			ManualLogSource log = ScorchedVoxelsPlugin.Log;
			log.LogInfo((object)"========== [SE-TELE] teleporter asset dump ==========");
			log.LogInfo((object)$"[SE-TELE] instance '{((Object)tp).name}' pos {((Component)tp).transform.position} root '{((Object)((Component)tp).transform.root).name}'");
			DumpNode(((Component)tp).transform, 0);
			ModelLocator component = ((Component)tp).GetComponent<ModelLocator>();
			Transform val = (((Object)(object)component != (Object)null) ? component.modelTransform : null);
			if ((Object)(object)val != (Object)null && !val.IsChildOf(((Component)tp).transform))
			{
				log.LogInfo((object)$"[SE-TELE] --- ModelLocator.modelTransform is SEPARATE: '{((Object)val).name}' pos {val.position} ---");
				DumpNode(val, 0);
			}
			else
			{
				log.LogInfo((object)("[SE-TELE] ModelLocator.modelTransform = " + (((Object)(object)val != (Object)null) ? ("'" + ((Object)val).name + "' (child of instance)") : "null")));
			}
			log.LogInfo((object)"========== [SE-TELE] end dump ==========");
		}

		private static void DumpNode(Transform t, int depth)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = ScorchedVoxelsPlugin.Log;
			string text = new string(' ', depth * 2);
			MeshFilter component = ((Component)t).GetComponent<MeshFilter>();
			MeshCollider component2 = ((Component)t).GetComponent<MeshCollider>();
			MeshRenderer component3 = ((Component)t).GetComponent<MeshRenderer>();
			string text2 = (((Object)(object)component != (Object)null || (Object)(object)component2 != (Object)null || (Object)(object)component3 != (Object)null) ? "" : " (no mesh)");
			log.LogInfo((object)$"[SE-TELE] {text}> '{((Object)t).name}' layer={LayerMask.LayerToName(((Component)t).gameObject.layer)} active={((Component)t).gameObject.activeInHierarchy}{text2}");
			Bounds bounds;
			if ((Object)(object)component != (Object)null && (Object)(object)component.sharedMesh != (Object)null)
			{
				bounds = component.sharedMesh.bounds;
				Vector3 size = ((Bounds)(ref bounds)).size;
				Vector3 val = Vector3.Scale(size, t.lossyScale);
				log.LogInfo((object)$"[SE-TELE] {text}    MeshFilter '{((Object)component.sharedMesh).name}' local {size.x:F1}x{size.y:F1}x{size.z:F1}m world {val.x:F1}x{val.y:F1}x{val.z:F1}m readable={component.sharedMesh.isReadable}");
			}
			if ((Object)(object)component2 != (Object)null)
			{
				string text3 = (((Object)(object)component2.sharedMesh != (Object)null) ? ((Object)component2.sharedMesh).name : "<none>");
				bounds = ((Collider)component2).bounds;
				Vector3 size2 = ((Bounds)(ref bounds)).size;
				log.LogInfo((object)$"[SE-TELE] {text}    MeshCollider '{text3}' worldBBox {size2.x:F1}x{size2.y:F1}x{size2.z:F1}m convex={component2.convex} trigger={((Collider)component2).isTrigger}");
			}
			if ((Object)(object)component3 != (Object)null)
			{
				Material sharedMaterial = ((Renderer)component3).sharedMaterial;
				log.LogInfo((object)string.Format("[SE-TELE] {0}    MeshRenderer mat '{1}' shader '{2}' enabled={3} shadow={4}", text, ((Object)(object)sharedMaterial != (Object)null) ? ((Object)sharedMaterial).name : "null", ((Object)(object)sharedMaterial != (Object)null && (Object)(object)sharedMaterial.shader != (Object)null) ? ((Object)sharedMaterial.shader).name : "null", ((Renderer)component3).enabled, ((Renderer)component3).shadowCastingMode));
			}
			for (int i = 0; i < t.childCount; i++)
			{
				DumpNode(t.GetChild(i), depth + 1);
			}
		}

		private static bool IsTeleporterAsset(Transform t)
		{
			TeleporterInteraction instance = TeleporterInteraction.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)t == (Object)null)
			{
				return false;
			}
			if (t.IsChildOf(((Component)instance).transform))
			{
				return true;
			}
			ModelLocator component = ((Component)instance).GetComponent<ModelLocator>();
			Transform val = (((Object)(object)component != (Object)null) ? component.modelTransform : null);
			if ((Object)(object)val != (Object)null)
			{
				return t.IsChildOf(val);
			}
			return false;
		}

		private static void CountEdge(int a, int b)
		{
			if (a != b)
			{
				long key = ((a < b) ? (((long)a << 32) | (uint)b) : (((long)b << 32) | (uint)a));
				edgeScratch.TryGetValue(key, out var value);
				edgeScratch[key] = value + 1;
			}
		}

		private static List<SourceMesh> GatherSources()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Invalid comparison between Unknown and I4
			//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)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0982: Unknown result type (might be due to invalid IL or missing references)
			//IL_0987: Unknown result type (might be due to invalid IL or missing references)
			//IL_0994: Unknown result type (might be due to invalid IL or missing references)
			//IL_0999: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_09af: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09da: Unknown result type (might be due to invalid IL or missing references)
			//IL_09dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a00: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a05: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a73: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a75: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a83: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dcd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd2: Unknown result type (might be due to invalid IL or missing references)
			List<SourceMesh> list = new List<SourceMesh>();
			Scene activeScene = SceneManager.GetActiveScene();
			if (MapRules.SkipEntireScene(((Scene)(ref activeScene)).name))
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] '" + ((Scene)(ref activeScene)).name + "' stays fully vanilla by per-map rule (Simulacrum)"));
				return list;
			}
			int intVal = LayerIndex.world.intVal;
			string[] array = EffExcludedNames.Split(',');
			float effMinTerrainSize = EffMinTerrainSize;
			gatheredGroundNodes = NodeGraphAdjuster.GroundNodePositions();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			MeshCollider[] array2 = Object.FindObjectsOfType<MeshCollider>();
			foreach (MeshCollider val in array2)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.sharedMesh == (Object)null || ((Component)val).gameObject.scene != activeScene || ((Collider)val).isTrigger || val.convex || ((Component)val).gameObject.layer != intVal || (Object)(object)((Collider)val).attachedRigidbody != (Object)null || (Object)(object)((Component)val).GetComponentInParent<LODGroup>() != (Object)null)
				{
					continue;
				}
				if (((Component)val).GetComponentInParent<IInteractable>() != null)
				{
					num5++;
					continue;
				}
				if (IsTeleporterAsset(((Component)val).transform))
				{
					num6++;
					continue;
				}
				MeshRenderer component = ((Component)val).GetComponent<MeshRenderer>();
				if ((Object)(object)component == (Object)null || !((Renderer)component).enabled)
				{
					num2++;
					continue;
				}
				if (((Renderer)component).forceRenderingOff)
				{
					num4++;
					continue;
				}
				if ((int)((Renderer)component).shadowCastingMode == 3)
				{
					num3++;
					continue;
				}
				Material sharedMaterial = ((Renderer)component).sharedMaterial;
				if ((Object)(object)sharedMaterial != (Object)null && (Object)(object)sharedMaterial.shader != (Object)null && ((Object)sharedMaterial.shader).name.StartsWith("Hopoo Games/FX/", StringComparison.OrdinalIgnoreCase))
				{
					num10++;
					if (ModOptions.VerboseLogging.Value)
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] left FX-shader mesh '" + ((Object)((Component)val).gameObject).name + "' vanilla ('" + ((Object)sharedMaterial.shader).name + "')"));
					}
					continue;
				}
				bool flag = false;
				string[] array3 = array;
				for (int j = 0; j < array3.Length; j++)
				{
					string text = array3[j].Trim();
					if (text.Length != 0 && (((Object)((Component)val).gameObject).name.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0 || ((Object)(object)sharedMaterial != (Object)null && ((Object)sharedMaterial).name.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0) || ((Object)(object)sharedMaterial != (Object)null && (Object)(object)sharedMaterial.shader != (Object)null && ((Object)sharedMaterial.shader).name.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					continue;
				}
				if (MapRules.ShouldSkip(((Scene)(ref activeScene)).name, ((Object)((Component)val).gameObject).name, ((Object)(object)sharedMaterial != (Object)null) ? ((Object)sharedMaterial).name : null))
				{
					num9++;
					if (ModOptions.VerboseLogging.Value)
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] left '" + ((Object)((Component)val).gameObject).name + "' vanilla (per-map rule for '" + ((Scene)(ref activeScene)).name + "')"));
					}
					continue;
				}
				float num11 = effMinTerrainSize;
				Bounds bounds;
				if (num11 > 0f)
				{
					bounds = ((Collider)val).bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					float num12 = Mathf.Max(size.x, Mathf.Max(size.y, size.z));
					if (num12 <= num11)
					{
						num7++;
						if (ModOptions.VerboseLogging.Value)
						{
							ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] left small mesh '" + ((Object)((Component)val).gameObject).name + "' vanilla " + $"(collider bbox {size.x:F1}x{size.y:F1}x{size.z:F1}m, max {num12:F1}m <= {num11}m)"));
						}
						continue;
					}
				}
				bounds = ((Collider)val).bounds;
				Vector3 size2 = ((Bounds)(ref bounds)).size;
				float num13 = Mathf.Max(size2.x, Mathf.Max(size2.y, size2.z));
				if (num13 > 2500f)
				{
					num8++;
					if (ModOptions.VerboseLogging.Value)
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] left backdrop-scale mesh '" + ((Object)((Component)val).gameObject).name + "' vanilla " + $"(collider bbox {size2.x:F0}x{size2.y:F0}x{size2.z:F0}m, max {num13:F0}m > {2500f}m)"));
					}
					continue;
				}
				if (ModOptions.VerboseLogging.Value)
				{
					Bounds bounds2 = ((Collider)val).bounds;
					Material sharedMaterial2 = ((Renderer)component).sharedMaterial;
					ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] CONVERT '" + ((Object)((Component)val).gameObject).name + "' " + $"size {((Bounds)(ref bounds2)).size.x:F1}x{((Bounds)(ref bounds2)).size.y:F1}x{((Bounds)(ref bounds2)).size.z:F1}m center ({((Bounds)(ref bounds2)).center.x:F0},{((Bounds)(ref bounds2)).center.y:F0},{((Bounds)(ref bounds2)).center.z:F0}) " + "mat '" + (((Object)(object)sharedMaterial2 != (Object)null) ? ((Object)sharedMaterial2).name : "null") + "' shader '" + (((Object)(object)sharedMaterial2 != (Object)null && (Object)(object)sharedMaterial2.shader != (Object)null) ? ((Object)sharedMaterial2.shader).name : "null") + "'"));
				}
				Mesh sharedMesh = val.sharedMesh;
				MeshReadback.Data data = null;
				if (!sharedMesh.isReadable)
				{
					if (MeshReadback.Whitelisted(sharedMesh))
					{
						data = MeshReadback.TryRead(sharedMesh);
					}
					if (data == null)
					{
						num++;
						continue;
					}
				}
				Vector3[] array4 = ((data != null) ? data.verts : sharedMesh.vertices);
				Matrix4x4 localToWorldMatrix = ((Component)val).transform.localToWorldMatrix;
				for (int k = 0; k < array4.Length; k++)
				{
					array4[k] = ((Matrix4x4)(ref localToWorldMatrix)).MultiplyPoint3x4(array4[k]);
				}
				Vector2[] array5 = ((data != null) ? data.uv0 : sharedMesh.uv);
				Vector2[] array6 = ((data != null) ? data.uv2 : sharedMesh.uv2);
				if (array6 == null || array6.Length == 0)
				{
					array6 = array5;
				}
				int subMeshCount = sharedMesh.subMeshCount;
				int[] array7 = null;
				bool flag2 = data != null && subMeshCount <= 1;
				int[] array8;
				if (subMeshCount <= 1)
				{
					array8 = ((data != null) ? data.SubTriangles(0) : sharedMesh.triangles);
				}
				else
				{
					int[][] array9 = new int[subMeshCount][];
					int num14 = 0;
					for (int l = 0; l < subMeshCount; l++)
					{
						array9[l] = ((data != null) ? data.SubTriangles(l) : sharedMesh.GetTriangles(l));
						num14 += array9[l].Length;
					}
					array8 = new int[num14];
					array7 = new int[num14 / 3];
					int num15 = 0;
					for (int m = 0; m < subMeshCount; m++)
					{
						int[] array10 = array9[m];
						for (int n = 0; n < array10.Length; n += 3)
						{
							array7[num15 / 3] = m;
							array8[num15++] = array10[n];
							array8[num15++] = array10[n + 1];
							array8[num15++] = array10[n + 2];
						}
					}
				}
				if (((Matrix4x4)(ref localToWorldMatrix)).determinant < 0f)
				{
					if (flag2)
					{
						array8 = (int[])array8.Clone();
						flag2 = false;
					}
					for (int num16 = 0; num16 + 2 < array8.Length; num16 += 3)
					{
						ref int reference = ref array8[num16 + 1];
						ref int reference2 = ref array8[num16 + 2];
						int j = array8[num16 + 2];
						int num17 = array8[num16 + 1];
						reference = j;
						reference2 = num17;
					}
					ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] '" + ((Object)((Component)val).gameObject).name + "' is a mirrored (negative-scale) instance — reversed winding so rock fills below the surface"));
				}
				Material[] array11 = (((Object)(object)component != (Object)null) ? ((Renderer)component).sharedMaterials : null);
				int num18 = 0;
				if (array7 != null && array11 != null && array11.Length > 1)
				{
					int[] array12 = new int[subMeshCount];
					int[] array13 = array7;
					foreach (int num19 in array13)
					{
						array12[num19]++;
					}
					for (int num20 = 1; num20 < subMeshCount; num20++)
					{
						if (array12[num20] > array12[num18])
						{
							num18 = num20;
						}
					}
				}
				Material val2 = null;
				if (array11 != null && array11.Length != 0)
				{
					val2 = array11[Mathf.Min(num18, array11.Length - 1)] ?? array11[0];
				}
				int num21 = array8.Length / 3;
				Vector3[] array14 = (Vector3[])(object)new Vector3[num21];
				float[] array15 = new float[num21];
				for (int num22 = 0; num22 < num21; num22++)
				{
					Vector3 val3 = array4[array8[num22 * 3]];
					Vector3 val4 = array4[array8[num22 * 3 + 1]];
					Vector3 val5 = array4[array8[num22 * 3 + 2]];
					Vector3 val6 = (array14[num22] = (val3 + val4 + val5) / 3f);
					int num23 = num22;
					Vector3 val7 = val3 - val6;
					float sqrMagnitude = ((Vector3)(ref val7)).sqrMagnitude;
					val7 = val4 - val6;
					float sqrMagnitude2 = ((Vector3)(ref val7)).sqrMagnitude;
					val7 = val5 - val6;
					array15[num23] = Mathf.Sqrt(Mathf.Max(sqrMagnitude, Mathf.Max(sqrMagnitude2, ((Vector3)(ref val7)).sqrMagnitude)));
				}
				Color32[] array16 = ((data != null) ? data.colors : sharedMesh.colors32);
				bool flag3 = false;
				float num24 = 0.08f;
				if (num24 > 0f && array8.Length >= 3)
				{
					bounds = ((Collider)val).bounds;
					Vector3 size3 = ((Bounds)(ref bounds)).size;
					float num25 = Mathf.Max(size3.x, Mathf.Max(size3.y, size3.z));
					if (weldScratch == null)
					{
						weldScratch = new Dictionary<Vector3, int>();
					}
					weldScratch.Clear();
					int[] array17 = new int[array4.Length];
					for (int num26 = 0; num26 < array4.Length; num26++)
					{
						if (!weldScratch.TryGetValue(array4[num26], out var value))
						{
							value = weldScratch.Count;
							weldScratch[array4[num26]] = value;
						}
						array17[num26] = value;
					}
					if (edgeScratch == null)
					{
						edgeScratch = new Dictionary<long, int>();
					}
					edgeScratch.Clear();
					for (int num27 = 0; num27 + 2 < array8.Length; num27 += 3)
					{
						CountEdge(array17[array8[num27]], array17[array8[num27 + 1]]);
						CountEdge(array17[array8[num27 + 1]], array17[array8[num27 + 2]]);
						CountEdge(array17[array8[num27 + 2]], array17[array8[num27]]);
					}
					int num28 = 0;
					foreach (KeyValuePair<long, int> item in edgeScratch)
					{
						if (item.Value == 1)
						{
							num28++;
						}
					}
					float num29 = ((edgeScratch.Count > 0) ? ((float)num28 / (float)edgeScratch.Count) : 0f);
					flag3 = num29 > num24;
					if (flag3)
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)($"[ScorchedVoxels] '{((Object)((Component)val).gameObject).name}' ({num25:F0}m) is {num29:P0} open edges (> {num24:P0}) — " + $"voxelizing as a bounded solid (fill within its own bounds, min {4f:F0}m slab)"));
					}
					else if (ModOptions.VerboseLogging.Value && num28 > 0)
					{
						ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] '{((Object)((Component)val).gameObject).name}' welded open-edge ratio {num29:P1} — converting normally");
					}
				}
				int num30 = (((Object)(object)component != (Object)null) ? ((Renderer)component).lightmapIndex : (-1));
				if (num30 < 0 || num30 >= 65534)
				{
					num30 = -1;
				}
				list.Add(new SourceMesh
				{
					name = ((Object)((Component)val).gameObject).name,
					verts = array4,
					indices = array8,
					renderer = component,
					material = val2,
					materials = array11,
					carveScale = MaterialHardness.ScaleFor(sharedMaterial, val2),
					openShell = flag3,
					subOfTri = array7,
					dominantSub = num18,
					collider = val,
					uv0 = ((array5 != null && array5.Length != 0) ? array5 : null),
					colors = ((array16 != null && array16.Length != 0) ? array16 : null),
					triCenter = array14,
					triRadius = array15,
					uv2 = array6,
					lightmapIndex = num30,
					lightmapScaleOffset = (Vector4)(((Object)(object)component != (Object)null) ? ((Renderer)component).lightmapScaleOffset : new Vector4(1f, 1f, 0f, 0f)),
					hasVisibleRenderer = ((Object)(object)component != (Object)null && ((Renderer)component).enabled),
					shadowMode = (ShadowCastingMode)((!((Object)(object)component != (Object)null)) ? 1 : ((int)((Renderer)component).shadowCastingMode)),
					indicesAliasShared = flag2
				});
			}
			if (num > 0)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)$"[ScorchedVoxels] skipped {num} non-readable meshes (left vanilla)");
			}
			if (num8 > 0)
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] left {num8} backdrop-scale meshes (>{2500f:F0}m) vanilla so they can't coarsen the map's voxels");
			}
			if (num9 > 0)
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] left {num9} meshes vanilla by per-map rule for '{((Scene)(ref activeScene)).name}'");
			}
			if (num10 > 0)
			{
				ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] left {num10} FX-effect meshes (void walls, foam, godrays...) vanilla");
			}
			if (ModOptions.VerboseLogging.Value)
			{
				int num31 = num2 + num3 + num4;
				if (num31 > 0)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)($"[ScorchedVoxels] left {num31} invisible meshes fully vanilla " + $"(no-renderer {num2}, shadows-only {num3}, forced-off {num4})"));
				}
				if (num5 > 0)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] left {num5} interactable/moveable objects (chests, shrines...) as vanilla mesh");
				}
				if (num6 > 0)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] left {num6} teleporter meshes (model/platform) as vanilla mesh");
				}
				if (num7 > 0)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)$"[ScorchedVoxels] left {num7} prop-sized meshes (bbox <= {effMinTerrainSize}m, e.g. teleporter pad) as vanilla mesh");
				}
			}
			edgeScratch = null;
			weldScratch = null;
			MeshReadback.DropCache();
			return list;
		}

		internal static void OrientSources(List<SourceMesh> srcs, Vector3[] groundNodes, Func<bool> cancelled)
		{
			int cursor = -1;
			int num = Mathf.Clamp(Environment.ProcessorCount - 2, 1, Math.Min(14, srcs.Count));
			Task[] array = new Task[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = Task.Run(delegate
				{
					while (true)
					{
						int num2 = Interlocked.Increment(ref cursor);
						if (num2 >= srcs.Count || cancelled())
						{
							break;
						}
						OrientSource(srcs[num2], groundNodes);
					}
				});
			}
			Task.WaitAll(array);
		}

		private static void OrientSource(SourceMesh src, Vector3[] groundNodes)
		{
			WindingField windingField = new WindingField(src.verts, src.indices);
			var (num, num2) = windingField.NodeStandingEvidence(groundNodes);
			if (num2 >= 5 && num2 > 2 * num)
			{
				if (src.indicesAliasShared)
				{
					src.indices = (int[])src.indices.Clone();
					src.indicesAliasShared = false;
				}
				int[] indices = src.indices;
				for (int i = 0; i + 2 < indices.Length; i += 3)
				{
					ref int reference = ref indices[i + 1];
					ref int reference2 = ref indices[i + 2];
					int num3 = indices[i + 2];
					int num4 = indices[i + 1];
					reference = num3;
					reference2 = num4;
				}
				windingField.MarkFlipped();
				ScorchedVoxelsPlugin.Log.LogInfo((object)("[ScorchedVoxels] '" + src.name + "' collider is wound inside-out " + $"({num2} ground nodes stand on its back faces vs {num} on front) — flipped so rock fills the correct side"));
			}
			src.winding = windingField;
		}

		private static UvProjection ProjectUvs(VoxelVolume vol, int[] srcTris, Vector3 originWS, List<Vector3> localPos, ChunkMeshData reuse = null)
		{
			//IL_0254: 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_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: 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_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: 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_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: 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_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_056b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			SourceMesh source = vol.source;
			if (source == null || srcTris == null || srcTris.Length == 0)
			{
				return null;
			}
			Vector2[] uv = source.uv0;
			Vector2[] uv2 = source.uv2;
			Color32[] colors = source.colors;
			bool flag = uv != null && uv.Length != 0;
			bool flag2 = vol.lightmapIndex >= 0 && uv2 != null && uv2.Length != 0;
			bool flag3 = colors != null && colors.Length != 0;
			bool flag4 = vol.materials != null && vol.materials.Length > 1 && source.subOfTri != null;
			if (!flag && !flag2 && !flag3 && !flag4)
			{
				return null;
			}
			UvProjection uvProjection;
			if (reuse != null)
			{
				ChunkMeshData chunkMeshData = reuse;
				uvProjection = chunkMeshData.uvProj ?? (chunkMeshData.uvProj = new UvProjection());
				if (flag)
				{
					UvProjection uvProjection2 = uvProjection;
					chunkMeshData = reuse;
					List<Vector2> obj = chunkMeshData.uv0Store ?? (chunkMeshData.uv0Store = new List<Vector2>());
					List<Vector2> list = obj;
					uvProjection2.uv0 = obj;
					list.Clear();
				}
				else
				{
					uvProjection.uv0 = null;
				}
				if (flag2)
				{
					UvProjection uvProjection3 = uvProjection;
					chunkMeshData = reuse;
					List<Vector2> obj2 = chunkMeshData.uv2Store ?? (chunkMeshData.uv2Store = new List<Vector2>());
					List<Vector2> list = obj2;
					uvProjection3.uv2 = obj2;
					list.Clear();
				}
				else
				{
					uvProjection.uv2 = null;
				}
				if (flag3)
				{
					UvProjection uvProjection4 = uvProjection;
					chunkMeshData = reuse;
					List<Color> obj3 = chunkMeshData.colorsStore ?? (chunkMeshData.colorsStore = new List<Color>());
					List<Color> list2 = obj3;
					uvProjection4.col = obj3;
					list2.Clear();
				}
				else
				{
					uvProjection.col = null;
				}
				if (flag4)
				{
					if (reuse.triStore == null || reuse.triStore.Length < localPos.Count)
					{
						reuse.triStore = new int[Mathf.NextPowerOfTwo(localPos.Count)];
					}
					uvProjection.tri = reuse.triStore;
				}
				else
				{
					uvProjection.tri = null;
				}
			}
			else
			{
				uvProjection = new UvProjection
				{
					uv0 = (flag ? new List<Vector2>(localPos.Count) : null),
					uv2 = (flag2 ? new List<Vector2>(localPos.Count) : null),
					col = (flag3 ? new List<Color>(localPos.Count) : null),
					tri = (flag4 ? new int[localPos.Count] : null)
				};
			}
			Vector3[] verts = source.verts;
			int[] indices = source.indices;
			Vector3[] triCenter = source.triCenter;
			float[] triRadius = source.triRadius;
			int num = srcTris[0];
			for (int i = 0; i < localPos.Count; i++)
			{
				Vector3 val = originWS + localPos[i];
				int num2 = num * 3;
				Vector3 cp;
				int j;
				float num3 = MeshVoxelizer.PointTriClosest(val, verts[indices[num2]], verts[indices[num2 + 1]], verts[indices[num2 + 2]], out cp, out j);
				float num4 = Mathf.Sqrt(num3);
				int num5 = num;
				for (j = 0; j < srcTris.Length; j++)
				{
					int num6 = srcTris[j];
					if (num6 == num5)
					{
						continue;
					}
					float num7 = val.x - triCenter[num6].x;
					float num8 = val.y - triCenter[num6].y;
					float num9 = val.z - triCenter[num6].z;
					float num10 = triRadius[num6] + num4;
					if (!(num7 * num7 + num8 * num8 + num9 * num9 > num10 * num10))
					{
						int num11 = num6 * 3;
						Vector3 cp2;
						int feature;
						float num12 = MeshVoxelizer.PointTriClosest(val, verts[indices[num11]], verts[indices[num11 + 1]], verts[indices[num11 + 2]], out cp2, out feature);
						if (num12 < num3)
						{
							num3 = num12;
							num4 = Mathf.Sqrt(num12);
							cp = cp2;
							num5 = num6;
						}
					}
				}
				num = num5;
				if (uvProjection.tri != null)
				{
					uvProjection.tri[i] = num5;
				}
				if (num5 < 0)
				{
					uvProjection.uv0?.Add(Vector2.zero);
					uvProjection.uv2?.Add(Vector2.zero);
					uvProjection.col?.Add(Color.white);
					continue;
				}
				int num13 = num5 * 3;
				int num14 = indices[num13];
				int num15 = indices[num13 + 1];
				int num16 = indices[num13 + 2];
				BaryWeights(cp, verts[num14], verts[num15], verts[num16], out var u, out var v, out var w);
				uvProjection.uv0?.Add(uv[num14] * u + uv[num15] * v + uv[num16] * w);
				uvProjection.uv2?.Add(uv2[num14] * u + uv2[num15] * v + uv2[num16] * w);
				if (uvProjection.col != null)
				{
					Color val2 = Color32.op_Implicit(colors[num14]) * u + Color32.op_Implicit(colors[num15]) * v + Color32.op_Implicit(colors[num16]) * w;
					val2.r = Mathf.Clamp01(val2.r);
					val2.g = Mathf.Clamp01(val2.g);
					val2.b = Mathf.Clamp01(val2.b);
					val2.a = Mathf.Clamp01(val2.a);
					uvProjection.col.Add(val2);
				}
			}
			return uvProjection;
		}

		private static List<int>[] SplitBySubmesh(VoxelVolume vol, int[] closestTri, List<int> idx, ChunkMeshData reuse = null)
		{
			Material[] materials = vol.materials;
			if (materials == null || materials.Length <= 1)
			{
				return null;
			}
			int num = materials.Length;
			int[] array = vol.source?.subOfTri;
			int num2 = Mathf.Clamp(vol.dominantSub, 0, num - 1);
			List<int>[] array2;
			if (reuse != null && reuse.subStore != null && reuse.subStore.Length == num)
			{
				array2 = reuse.subStore;
				for (int i = 0; i < num; i++)
				{
					array2[i].Clear();
				}
			}
			else
			{
				array2 = new List<int>[num];
				for (int j = 0; j < num; j++)
				{
					array2[j] = new List<int>();
				}
				if (reuse != null)
				{
					reuse.subStore = array2;
				}
			}
			for (int k = 0; k + 2 < idx.Count; k += 3)
			{
				int num3 = idx[k];
				int num4 = idx[k + 1];
				int num5 = idx[k + 2];
				int num12;
				if (closestTri != null && array != null)
				{
					int num6 = closestTri[num3];
					int num7 = closestTri[num4];
					int num8 = closestTri[num5];
					int num9 = ((num6 >= 0) ? Mathf.Min(array[num6], num - 1) : num2);
					int num10 = ((num7 >= 0) ? Mathf.Min(array[num7], num - 1) : num2);
					int num11 = ((num8 >= 0) ? Mathf.Min(array[num8], num - 1) : num2);
					num12 = ((num10 == num11) ? num10 : num9);
				}
				else
				{
					num12 = num2;
				}
				array2[num12].Add(num3);
				array2[num12].Add(num4);
				array2[num12].Add(num5);
			}
			return array2;
		}

		private static void BaryWeights(Vector3 q, Vector3 a, Vector3 b, Vector3 c, out float u, out float v, out float w)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//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_000f: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0018: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			Vector3 val = b - a;
			Vector3 val2 = c - a;
			Vector3 val3 = q - a;
			float num = Vector3.Dot(val, val);
			float num2 = Vector3.Dot(val, val2);
			float num3 = Vector3.Dot(val2, val2);
			float num4 = Vector3.Dot(val3, val);
			float num5 = Vector3.Dot(val3, val2);
			float num6 = num * num3 - num2 * num2;
			if (Mathf.Abs(num6) < 1E-12f)
			{
				u = 1f;
				v = 0f;
				w = 0f;
			}
			else
			{
				v = (num3 * num4 - num2 * num5) / num6;
				w = (num * num5 - num2 * num4) / num6;
				u = 1f - v - w;
			}
		}

		internal static ChunkMeshData BuildFineChunkData(VoxelVolume vol, VoxelChunk chunk, long key, List<Vector3> pos, List<Vector3> nrm, List<int> idx, bool pooled)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			int num = chunk.cx * 16;
			int num2 = chunk.cy * 16;
			int num3 = chunk.cz * 16;
			if (!SurfaceNets.Build(vol, num, num2, num3, 1, chunk.density, vol.renderable ? RivalsFor(vol, key) : null, pos, nrm, idx))
			{
				return null;
			}
			Vector3 originWS = new Vector3((float)num, (float)num2, (float)num3) * vol.voxelSize;
			if (pooled)
			{
				ChunkMeshData chunkMeshData = ChunkMeshDataPool.Take();
				UvProjection uvProjection = (vol.renderable ? ProjectUvs(vol, chunk.srcTris, originWS, pos, chunkMeshData) : null);
				List<int>[] array = (vol.renderable ? SplitBySubmesh(vol, uvProjection?.tri, idx, chunkMeshData) : null);
				chunkMeshData.positions.AddRange(pos);
				chunkMeshData.normals.AddRange(nrm);
				chunkMeshData.uv0 = uvProjection?.uv0;
				chunkMeshData.uv2 = uvProjection?.uv2;
				chunkMeshData.colors = uvProjection?.col;
				if (array != null)
				{
					chunkMeshData.subIndices = array;
				}
				else
				{
					ChunkMeshData chunkMeshData2 = chunkMeshData;
					chunkMeshData.indices = chunkMeshData2.indicesStore ?? (chunkMeshData2.indicesStore = new List<int>());
					chunkMeshData.indices.Clear();
					chunkMeshData.indices.AddRange(idx);
				}
				return chunkMeshData;
			}
			UvProjection uvProjection2 = (vol.renderable ? ProjectUvs(vol, chunk.srcTris, originWS, pos) : null);
			List<int>[] array2 = (vol.renderable ? SplitBySubmesh(vol, uvProjection2?.tri, idx) : null);
			return new ChunkMeshData
			{
				positions = new List<Vector3>(pos),
				normals = new List<Vector3>(nrm),
				indices = ((array2 == null) ? new List<int>(idx) : null),
				uv0 = uvProjection2?.uv0,
				uv2 = uvProjection2?.uv2,
				colors = uvProjection2?.col,
				subIndices = array2
			};
		}

		private static List<VoxelVolume> RivalsFor(VoxelVolume vol, long key)
		{
			List<VoxelVolume> rivalCandidates = vol.rivalCandidates;
			if (rivalCandidates == null)
			{
				return null;
			}
			List<VoxelVolume> list = null;
			int num = VoxelVolume.UnpackSigned(key >> 42);
			int num2 = VoxelVolume.UnpackSigned(key >> 21);
			int num3 = VoxelVolume.UnpackSigned(key);
			for (int i = 0; i < rivalCandidates.Count; i++)
			{
				VoxelVolume voxelVolume = rivalCandidates[i];
				if (voxelVolume.chunks.ContainsKey(key) || voxelVolume.chunks.ContainsKey(VoxelVolume.PackKey(num + 1, num2, num3)) || voxelVolume.chunks.ContainsKey(VoxelVolume.PackKey(num - 1, num2, num3)) || voxelVolume.chunks.ContainsKey(VoxelVolume.PackKey(num, num2 + 1, num3)) || voxelVolume.chunks.ContainsKey(VoxelVolume.PackKey(num, num2 - 1, num3)) || voxelVolume.chunks.ContainsKey(VoxelVolume.PackKey(num, num2, num3 + 1)) || voxelVolume.chunks.ContainsKey(VoxelVolume.PackKey(num, num2, num3 - 1)))
				{
					if (list == null)
					{
						list = new List<VoxelVolume>(2);
					}
					list.Add(voxelVolume);
				}
			}
			return list;
		}

		private static List<VoxelVolume> GroupRivals(VoxelGroup g)
		{
			List<VoxelVolume> rivalCandidates = g.vol.rivalCandidates;
			if (rivalCandidates == null)
			{
				return null;
			}
			List<VoxelVolume> list = null;
			for (int i = 0; i < rivalCandidates.Count; i++)
			{
				VoxelVolume voxelVolume = rivalCandidates[i];
				bool flag = false;
				foreach (VoxelChunk member in g.members)
				{
					if (voxelVolume.chunks.ContainsKey(VoxelVolume.PackKey(member.cx, member.cy, member.cz)))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					if (list == null)
					{
						list = new List<VoxelVolume>(2);
					}
					list.Add(voxelVolume);
				}
			}
			return list;
		}

		private static bool Outranks(VoxelVolume a, VoxelVolume b)
		{
			if (a.priority == b.priority)
			{
				return a.index < b.index;
			}
			return a.priority > b.priority;
		}

		private static bool VisiblySolid(VoxelVolume v)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			if (v.renderable)
			{
				return (int)v.shadowMode != 3;
			}
			return false;
		}

		internal static bool IsModdedUser(uint userNetId)
		{
			return StageSyncCoordinator.IsModdedUser(userNetId);
		}

		public static void OnRunDestroy()
		{
			Reset();
			ChunkMeshDataPool.Drop();
			CarveWorker.DropPools();
			StageSyncCoordinator.OnRunDestroy();
			LootReveal.Reset();
			HostConfig.valid = false;
		}

		public static void OnStageStart(Stage stage)
		{
			int num = (((Object)(object)stage != (Object)null) ? ((Object)stage).GetInstanceID() : 0);
			if (num != 0 && num == convertedStageId)
			{
				ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] duplicate stage-start for the same Stage instance — ignored (already converting/converted)");
				return;
			}
			UserLifetimeStats.OnStageAdvance();
			Reset();
			NodeGraphAdjuster.OnStageStart();
			convertedStageId = num;
			StageSyncCoordinator.OnStageStart();
			if (ModOptions.MemoryReport.Value)
			{
				baselineNative = Profiler.GetTotalReservedMemoryLong();
				baselineMono = Profiler.GetMonoHeapSizeLong();
			}
			if (NetworkServer.active)
			{
				CarveStats.OnStageAdvance();
			}
			TitleSystem.OnStageAdvance();
			if (IsRemoteClient)
			{
				StageSyncCoordinator.SendLifetimeBase();
			}
			if (NetworkServer.active && NetworkServer.connections.Count > 0)
			{
				SendStageConfig();
			}
			if (!ModOptions.Enabled.Value)
			{
				if (IsRemoteClient)
				{
					StageSyncCoordinator.SendClientReady();
				}
				return;
			}
			stageSeed = 12345u;
			if ((Object)(object)Run.instance != (Object)null)
			{
				stageSeed = (uint)((int)Run.instance.seed ^ (int)(Run.instance.stageClearCount * 2654435761u));
			}
			if (IsRemoteClient)
			{
				if (!UseHostConfig)
				{
					state = State.WaitingForHost;
					hostConfigDeadline = Time.realtimeSinceStartup + 8f;
					StageSyncCoordinator.FreezeForLoading();
					ConvertProgress.Set("waiting for host", 1);
				}
				else
				{
					ProceedUnderHostConfig();
				}
			}
			else
			{
				BeginConversion();
			}
		}

		internal static void SendStageConfig()
		{
			NetMessageExtensions.Send((INetMessage)(object)new StageConfigMessage(StageKey(), "0.20.72", ModOptions.Enabled.Value, ModOptions.VoxelSize.Value, ModOptions.MinTerrainSize.Value, ModOptions.MaxCarveRadius.Value, ModOptions.ExcludedNames.Value, ModOptions.BloodAmount.Value), (NetworkDestination)1);
		}

		public static void StoreHostConfig(int stageKey, string version, bool enabled, float voxelSize, float minTerrainSize, float maxCarveRadius, string excludedNames, float bloodAmount)
		{
			HostConfig.valid = true;
			HostConfig.stageKey = stageKey;
			HostConfig.version = version;
			HostConfig.enabled = enabled;
			HostConfig.voxelSize = voxelSize;
			HostConfig.minTerrainSize = minTerrainSize;
			HostConfig.maxCarveRadius = maxCarveRadius;
			HostConfig.excludedNames = excludedNames;
			HostConfig.bloodAmount = bloodAmount;
		}

		private static void ProceedUnderHostConfig()
		{
			if (!HostConfig.enabled)
			{
				if (ModOptions.VerboseLogging.Value)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)"[ScorchedVoxels] host has the mod disabled — staying vanilla");
				}
				StayVanilla();
			}
			else if (HostConfig.version != "0.20.72")
			{
				WarnVersionMismatch();
				StayVanilla();
			}
			else
			{
				BeginConversion();
			}
		}

		private static void WarnVersionMismatch()
		{
			if (!versionMismatchWarned)
			{
				versionMismatchWarned = true;
				string text = "<color=#ff7755>[ScorchedVoxels] version 0.20.72 does not match the host's " + HostConfig.version + " — terrain stays VANILLA on this machine. Everyone should run the same version.</color>";
				ScorchedVoxelsPlugin.Log.LogError((object)text);
				Chat.AddMessage(text);
			}
		}

		private static void StayVanilla()
		{
			if (IsRemoteClient)
			{
				StageSyncCoordinator.SendClientReady();
			}
			StageSyncCoordinator.Unfreeze();
			state = State.Idle;
		}

		private static void FailToVanilla()
		{
			if (IsRemoteClient)
			{
				StageSyncCoordinator.SendClientReady();
			}
			StageSyncCoordinator.Unfreeze();
			if ((Object)(object)root != (Object)null)
			{
				Object.Destroy((Object)(object)root);
			}
			root = null;
			state = State.Idle;
		}

		public static void Tick()
		{
			long t = GoreProf.Begin();
			DebrisSystem.Tick();
			GoreProf.End(33, t);
			GoreSystem.Tick();
			LoadingOverlay.Tick();
			t = GoreProf.Begin();
			FarewellBlast.Tick();
			GoreProf.End(36, t);
			t = GoreProf.Begin();
			NodeGraphAdjuster.Tick();
			GoreProf.End(34, t);
			t = GoreProf.Begin();
			TickTerrain();
			GoreProf.End(35, t);
		}

		private static void TickTerrain()
		{
			//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_01ae: 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_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: 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)
			StageSyncCoordinator.Tick();
			if (state == State.WaitingForHost)
			{
				if (UseHostConfig)
				{
					ProceedUnderHostConfig();
				}
				else if (Time.realtimeSinceStartup > hostConfigDeadline)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)"[ScorchedVoxels] no stage config from the host (does the host run ScorchedVoxels?) — converting with local settings");
					BeginConversion();
				}
				return;
			}
			if (ModOptions.LogTeleporterAssets.Value && !teleporterDumped)
			{
				TeleporterInteraction instance = TeleporterInteraction.instance;
				if ((Object)(object)instance != (Object)null)
				{
					teleporterDumped = true;
					DumpTeleporterAssets(instance);
				}
			}
			if (state != State.Ready)
			{
				return;
			}
			if (pendingUploads.Count > 0)
			{
				long timestamp = Stopwatch.GetTimestamp();
				uploadScratch.Clear();
				uploadScratch.AddRange(pendingUploads.Keys);
				foreach (VoxelChunk item in uploadScratch)
				{
					if (Stopwatch.GetTimestamp() - timestamp >= UploadBudgetTicks)
					{
						break;
					}
					if (!item.bakeInFlight)
					{
						ChunkResult res = pendingUploads[item];
						pendingUploads.Remove(item);
						ApplyChunkResult(res);
						CarveWorker.ReturnResult(res);
					}
				}
				FlushColliderBakes();
			}
			if (++lodFrameCounter < 15)
			{
				return;
			}
			lodFrameCounter = 0;
			float value = ModOptions.LodDistance.Value;
			Camera main = Camera.main;
			if (!(value > 1f) || !((Object)(object)main != (Object)null))
			{
				return;
			}
			Vector3 position = ((Component)main).transform.position;
			float num = value * value;
			float num2 = value * 2.5f * (value * 2.5f);
			Vector3 val;
			foreach (VoxelGroup superGroup in superGroups)
			{
				int num3;
				if (!superGroup.carved && superGroup.coarseHasSurface)
				{
					val = superGroup.centerWS - position;
					num3 = ((((Vector3)(ref val)).sqrMagnitude > num2) ? 1 : 0);
				}
				else
				{
					num3 = 0;
				}
				bool flag = (byte)num3 != 0;
				if (flag != superGroup.showingCoarse)
				{
					superGroup.showingCoarse = flag;
					if ((Object)(object)superGroup.renderer != (Object)null)
					{
						((Renderer)superGroup.renderer).enabled = flag;
					}
				}
			}
			foreach (VoxelGroup group in groups)
			{
				bool flag2 = group.parentSuper != null && group.parentSuper.showingCoarse;
				int num4;
				if (!group.carved)
				{
					val = group.centerWS - position;
					if (((Vector3)(ref val)).sqrMagnitude > num && group.coarseHasSurface)
					{
						num4 = ((!flag2) ? 1 : 0);
						goto IL_0284;
					}
				}
				num4 = 0;
				goto IL_0284;
				IL_0284:
				bool flag3 = (byte)num4 != 0;
				bool flag4 = flag3 != group.showingCoarse;
				if (flag4)
				{
					group.showingCoarse = flag3;
					if ((Object)(object)group.renderer != (Object)null)
					{
						((Renderer)group.renderer).enabled = flag3;
					}
				}
				bool flag5 = !flag3 && !flag2;
				if (flag5 == group.lastShowFine && !flag4)
				{
					continue;
				}
				group.lastShowFine = flag5;
				foreach (VoxelChunk member in group.members)
				{
					if (!((Object)(object)member.renderer == (Object)null))
					{
						bool flag6 = flag5 && member.hasSurface;
						if (((Renderer)member.renderer).enabled != flag6)
						{
							((Renderer)member.renderer).enabled = flag6;
						}
					}
				}
			}
		}

		private static void BeginBake()
		{
			bakeIds = new List<int>();
			foreach (VoxelGroup group in groups)
			{
				if (group.fineCollision)
				{
					foreach (VoxelChunk member in group.members)
					{
						if ((Object)(object)member.mesh != (Object)null && member.hasSurface)
						{
							bakeIds.Add(((Object)member.mesh).GetInstanceID());
						}
					}
				}
				else if ((Object)(object)group.colMesh != (Object)null)
				{
					bakeIds.Add(((Object)group.colMesh).GetInstanceID());
				}
			}
			ConvertProgress.Set("baking colliders", bakeIds.Count);
			state = State.Baking;
			int myEpoch = epoch;
			List<int> ids = bakeIds;
			int num = Mathf.Clamp(Environment.ProcessorCount - 1, 1, 16);
			Task[] tasks = new Task[num];
			int cursor = -1;
			int bakeFails = 0;
			for (int i = 0; i < num; i++)
			{
				tasks[i] = Task.Run(delegate
				{
					while (true)
					{
						int num2 = Interlocked.Increment(ref cursor);
						if (num2 >= ids.Count)
						{
							break;
						}
						try
						{
							Physics.BakeMesh(ids[num2], false);
						}
						catch
						{
							Interlocked.Increment(ref bakeFails);
						}
						Interlocked.Increment(ref ConvertProgress.Done);
					}
				});
			}
			Task.Run(delegate
			{
				try
				{
					Task.WaitAll(tasks);
				}
				catch (Exception ex)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] collider bake wait failed: " + ex.Message));
				}
				MainThread.Post(delegate
				{
					if (epoch == myEpoch)
					{
						if (bakeFails > 0)
						{
							ScorchedVoxelsPlugin.Log.LogWarning((object)$"[ScorchedVoxels] {bakeFails} of {ids.Count} collider bakes failed — those chunks cook lazily on first contact instead");
						}
						FinishSwap();
					}
				});
			});
		}

		private static void FinishSwap()
		{
			//IL_08a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c9: Unknown result type (might be due to invalid IL or missing references)
			HashSet<VoxelVolume> doomed = new HashSet<VoxelVolume>();
			HashSet<SourceMesh> hashSet = new HashSet<SourceMesh>();
			foreach (VoxelVolume volume in volumes)
			{
				SourceMesh source = volume.source;
				if (source == null || (Object)(object)source.collider == (Object)null || !((Component)source.collider).gameObject.activeInHierarchy || IsTeleporterAsset(((Component)source.collider).transform))
				{
					doomed.Add(volume);
					if (source != null)
					{
						hashSet.Add(source);
					}
				}
			}
			int num = 0;
			foreach (FineItem fineItem in fineItems)
			{
				if (!((Object)(object)fineItem.chunk.go == (Object)null) && fineItem.chunk.hasSurface)
				{
					if (doomed.Contains(fineItem.vol))
					{
						fineItem.chunk.go.SetActive(false);
					}
					else
					{
						num++;
					}
				}
			}
			int num2 = 0;
			int num3 = 0;
			foreach (VoxelGroup group in groups)
			{
				if (doomed.Contains(group.vol))
				{
					continue;
				}
				if (group.fineCollision)
				{
					foreach (VoxelChunk member in group.members)
					{
						if (!((Object)(object)member.go == (Object)null) && member.hasSurface && !((Object)(object)member.collider != (Object)null))
						{
							member.collider = member.go.AddComponent<MeshCollider>();
							member.collider.sharedMesh = member.mesh;
							num3++;
						}
					}
				}
				else if ((Object)(object)group.colMesh != (Object)null)
				{
					group.colGo = new GameObject(((Object)group.colMesh).name);
					group.colGo.transform.SetParent(root.transform, false);
					group.colGo.transform.position = new Vector3((float)group.gx, (float)group.gy, (float)group.gz) * (32f * group.vol.voxelSize);
					group.colGo.layer = LayerIndex.world.intVal;
					group.colCollider = group.colGo.AddComponent<MeshCollider>();
					group.colCollider.sharedMesh = group.colMesh;
					num2++;
				}
			}
			foreach (FineItem fineItem2 in fineItems)
			{
				if (!((Object)(object)fineItem2.chunk.mesh == (Object)null) && fineItem2.vol.renderable && !doomed.Contains(fineItem2.vol) && (!groupLookup[fineItem2.vol].TryGetValue(GroupKeyOf(fineItem2.chunk.cx, fineItem2.chunk.cy, fineItem2.chunk.cz), out var value) || !value.fineCollision))
				{
					fineItem2.chunk.mesh.UploadMeshData(true);
				}
			}
			foreach (VoxelGroup group2 in groups)
			{
				if ((Object)(object)group2.go != (Object)null && doomed.Contains(group2.vol))
				{
					group2.go.SetActive(false);
				}
			}
			foreach (VoxelGroup superGroup in superGroups)
			{
				if ((Object)(object)superGroup.go != (Object)null && doomed.Contains(superGroup.vol))
				{
					superGroup.go.SetActive(false);
				}
			}
			foreach (SourceMesh source2 in sources)
			{
				if (!hashSet.Contains(source2))
				{
					if ((Object)(object)source2.renderer != (Object)null)
					{
						((Renderer)source2.renderer).enabled = false;
					}
					if ((Object)(object)source2.collider != (Object)null)
					{
						((Collider)source2.collider).enabled = false;
					}
				}
			}
			if (doomed.Count > 0)
			{
				foreach (VoxelVolume item in doomed)
				{
					foreach (KeyValuePair<long, VoxelChunk> chunk in item.chunks)
					{
						if ((Object)(object)chunk.Value.mesh != (Object)null)
						{
							Object.Destroy((Object)(object)chunk.Value.mesh);
							chunk.Value.mesh = null;
						}
					}
				}
				foreach (VoxelGroup group3 in groups)
				{
					if (doomed.Contains(group3.vol))
					{
						if ((Object)(object)group3.mesh != (Object)null)
						{
							Object.Destroy((Object)(object)group3.mesh);
							group3.mesh = null;
						}
						if ((Object)(object)group3.colMesh != (Object)null)
						{
							Object.Destroy((Object)(object)group3.colMesh);
							group3.colMesh = null;
						}
					}
				}
				foreach (VoxelGroup superGroup2 in superGroups)
				{
					if (doomed.Contains(superGroup2.vol) && (Object)(object)superGroup2.mesh != (Object)null)
					{
						Object.Destroy((Object)(object)superGroup2.mesh);
						superGroup2.mesh = null;
					}
				}
				volumes.RemoveAll((VoxelVolume v) => doomed.Contains(v));
				groups.RemoveAll((VoxelGroup g) => doomed.Contains(g.vol));
				superGroups.RemoveAll((VoxelGroup g) => doomed.Contains(g.vol));
				foreach (VoxelVolume item2 in doomed)
				{
					groupLookup.Remove(item2);
					superLookup.Remove(item2);
				}
				foreach (VoxelVolume volume2 in volumes)
				{
					volume2.rivalCandidates?.RemoveAll(doomed.Contains);
				}
				sources.RemoveAll(hashSet.Contains);
				if (ModOptions.VerboseLogging.Value)
				{
					ScorchedVoxelsPlugin.Log.LogInfo((object)($"[ScorchedVoxels] dropped {doomed.Count} volume(s) the game hid after gather " + "(map variety / toggled-off) — left vanilla, no phantom geometry"));
				}
			}
			fineItems = null;
			bakeIds = null;
			state = State.Ready;
			ManualLogSource log = ScorchedVoxelsPlugin.Log;
			string[] obj = new string[7] { "[ScorchedVoxels] '", null, null, null, null, null, null };
			Scene activeScene = SceneManager.GetActiveScene();
			obj[1] = ((Scene)(ref activeScene)).name;
			obj[2] = "' ";
			obj[3] = $"stage converted: {volumes.Count} volumes, {num} surface chunks, ";
			obj[4] = $"{groups.Count} LOD groups + {superGroups.Count} far-LOD groups, ";
			obj[5] = $"{num2} group colliders + {num3} fine colliders (thin geometry), ";
			obj[6] = $"total {Time.realtimeSinceStartup - convertStart:F1}s";
			log.LogInfo((object)string.Concat(obj));
			if (ModOptions.MemoryReport.Value)
			{
				try
				{
					LogMemoryReport();
				}
				catch (Exception ex)
				{
					ScorchedVoxelsPlugin.Log.LogWarning((object)("[ScorchedVoxels] memory report failed: " + ex.Message));
				}
			}
			while (preReadyCarves.Count > 0)
			{
				var (pos, r, attacker) = preReadyCarves.Dequeue();
				EnqueueCarveJob(pos, r, attacker);
			}
			GoreSystem.WarmUp();
			StageSyncCoordinator.OnLocalConversionDone();
		}

		private static void UploadFineMesh(VoxelVolume vol, VoxelChunk chunk, ChunkMeshData data)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_009f: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_034e: 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_0167: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)chunk.go == (Object)null)
			{
				chunk.go = new GameObject($"vox{vol.index}_{chunk.cx}_{chunk.cy}_{chunk.cz}");
				chunk.go.transform.SetParent(root.transform, false);
				chunk.go.transform.position = new Vector3((float)chunk.cx, (float)chunk.cy, (float)chunk.cz) * (16f * vol.voxelSize);
				chunk.go.layer = LayerIndex.world.intVal;
				chunk.mesh = new Mesh
				{
					name = ((Object)chunk.go).name
				};
				if (vol.renderable)
				{
					chunk.filter = chunk.go.AddComponent<MeshFilter>();
					chunk.filter.sharedMesh = chunk.mesh;
					chunk.renderer = chunk.go.AddComponent<MeshRenderer>();
					if (vol.materials != null && vol.materials.Length > 1)
					{
						((Renderer)chunk.renderer).sharedMaterials = vol.materials;
					}
					else
					{
						((Renderer)chunk.renderer).sharedMaterial = vol.material;
					}
					((Renderer)chunk.renderer).shadowCastingMode = vol.shadowMode;
					ApplyLightmap(chunk.renderer, vol, data.uv2 != null);
				}
				if (state != State.Ready)
				{
					chunk.hasSurface = true;
					FillMesh(chunk.mesh, data, FineMeshBounds(vol));
					return;
				}
				Dictionary<long, VoxelGroup> dictionary = groupLookup[vol];
				int gx = chunk.cx >> 1;
				int gy = chunk.cy >> 1;
				int gz = chunk.cz >> 1;
				long key = GroupKeyOf(chunk.cx, chunk.cy, chunk.cz);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = MakeGroup(vol, gx, gy, gz, 2);
					value.carved = true;
					value.fineCollision = true;
					dictionary[key] = value;
					groups.Add(value);
				}
				value.members.Add(chunk);
				if (vol.renderable)
				{
					if (value.parentSuper == null && superLookup.TryGetValue(vol, out var value2))
					{
						int num = chunk.cx >> 2;
						int num2 = chunk.cy >> 2;
						int num3 = chunk.cz >> 2;
						long key2 = VoxelVolume.PackKey(num, num2, num3);
						if (!value2.TryGetValue(key2, out var value3))
						{
							value3 = MakeGroup(vol, num, num2, num3, 4);
							value3.carved = true;
							value2[key2] = value3;
							superGroups.Add(value3);
						}
						value.parentSuper = value3;
					}
					value.parentSuper?.members.Add(chunk);
					if (value.showingCoarse || (value.parentSuper != null && value.parentSuper.showingCoarse))
					{
						((Renderer)chunk.renderer).enabled = false;
					}
				}
			}
			else
			{
				if ((Object)(object)chunk.renderer != (Object)null)
				{
					((Renderer)chunk.renderer).enabled = true;
				}
				if ((Object)(object)chunk.collider != (Object)null)
				{
					((Collider)chunk.collider).enabled = true;
				}
			}
			chunk.hasSurface = true;
			FillMesh(chunk.mesh, data, FineMeshBounds(vol));
		}

		private static void UploadGroupMesh(VoxelGroup g, ChunkMeshData data)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00b2: 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_01ec: 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_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			if ((Object)(object)g.go == (Object)null)
			{
				g.go = new GameObject($"voxlod{g.step}_{g.vol.index}_{g.gx}_{g.gy}_{g.gz}");
				g.go.transform.SetParent(root.transform, false);
				g.go.transform.position = new Vector3((float)g.gx, (float)g.gy, (float)g.gz) * ((float)(16 * g.step) * g.vol.voxelSize);
				g.go.layer = LayerIndex.world.intVal;
				g.filter = g.go.AddComponent<MeshFilter>();
				g.renderer = g.go.AddComponent<MeshRenderer>();
				if (g.vol.materials != null && g.vol.materials.Length > 1)
				{
					((Renderer)g.renderer).sharedMaterials = g.vol.materials;
				}
				else
				{
					((Renderer)g.renderer).sharedMaterial = g.vol.material;
				}
				((Renderer)g.renderer).shadowCastingMode = g.vol.shadowMode;
				ApplyLightmap(g.renderer, g.vol, data.uv2 != null);
				((Renderer)g.renderer).enabled = g.showingCoarse;
				g.mesh = new Mesh
				{
					name = ((Object)g.go).name
				};
				g.filter.sharedMesh = g.mesh;
			}
			else if (g.showingCoarse)
			{
				((Renderer)g.renderer).enabled = true;
			}
			g.coarseHasSurface = true;
			FillMesh(g.mesh, data, GroupMeshBounds(g));
			g.mesh.UploadMeshData(true);
		}

		internal static void FillMesh(Mesh mesh, ChunkMeshData data, Bounds bounds)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			mesh.Clear();
			mesh.SetVertices(data.positions);
			mesh.SetNormals(data.normals);
			if (data.uv0 != null)
			{
				mesh.SetUVs(0, data.uv0);
			}
			if (data.uv2 != null)
			{
				mesh.SetUVs(1, data.uv2);
			}
			if (data.colors != null)
			{
				mesh.SetColors(data.colors);
			}
			if (data.subIndices != null)
			{
				mesh.subMeshCount = data.subIndices.Length;
				for (int i = 0; i < data.subIndices.Length; i++)
				{
					mesh.SetTriangles(data.subIndices[i], i, false, 0);
				}
			}
			else
			{
				mesh.SetTriangles(data.indices, 0, false, 0);
			}
			mesh.bounds = bounds;
		}

		private static Bounds LocalMeshBounds(float cellSize, float extraPad)
		{
			//IL_000e: 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_002a: 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)
			float num = cellSize + extraPad;
			float num2 = 16f * cellSize;
			Bounds result = default(Bounds);
			((Bounds)(ref result)).SetMinMax(new Vector3(0f - num, 0f - num, 0f - num), new Vector3(num2 + num, num2 + num, num2 + num));
			return result;
		}

		private static Bounds FineMeshBounds(VoxelVolume vol)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LocalMeshBounds(vol.voxelSize, 0f);
		}

		private static Bounds GroupMeshBounds(VoxelGroup g)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			float cellSize = g.vol.voxelSize * (float)g.step;
			return LocalMeshBounds(cellSize, SurfaceNets.SkirtDepth(g.vol, cellSize));
		}

		private static Bounds CollisionMeshBounds(VoxelGroup g)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return LocalMeshBounds(g.vol.voxelSize * (float)g.step, 0f);
		}

		private static void ApplyLightmap(MeshRenderer renderer, VoxelVolume vol, bool hasUv2)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (vol.lightmapIndex >= 0 && hasUv2)
			{
				((Renderer)renderer).lightmapIndex = vol.lightmapIndex;
				((Renderer)renderer).lightmapScaleOffset = vol.lightmapScaleOffset;
			}
		}
	}
	internal class VoxelVolume
	{
		internal struct ColumnEntry
		{
			public int cy;

			public bool topSolid;

			public bool bottomSolid;
		}

		private struct RimWrite
		{
			public int ix;

			public int iy;

			public int iz;

			public byte val;
		}

		private interface ICarveSdf
		{
			float Distance(Vector3 p);

			bool SkipUnstoredChunk(int cx, int cy, int cz);
		}

		private readonly struct SphereSdf : ICarveSdf
		{
			private readonly Vector3 pos;

			private readonly float r;

			private readonly float amp;

			private readonly float cutR;

			private readonly float chunkWorld;

			private readonly uint seed;

			public SphereSdf(Vector3 pos, float r, float amp, float cutR, uint seed, float chunkWorld)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				this.pos = pos;
				this.r = r;
				this.amp = amp;
				this.cutR = cutR;
				this.seed = seed;
				this.chunkWorld = chunkWorld;
			}

			public float Distance(Vector3 p)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Vector3 val = p - pos;
				return ((Vector3)(ref val)).magnitude - (r + ShapeNoise(p, seed) * amp);
			}

			public bool SkipUnstoredChunk(int cx, int cy, int cz)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				return DistanceToBox(pos, new Vector3((float)cx * chunkWorld, (float)cy * chunkWorld, (float)cz * chunkWorld), new Vector3((float)(cx + 1) * chunkWorld, (float)(cy + 1) * chunkWorld, (float)(cz + 1) * chunkWorld)) > cutR;
			}
		}

		private readonly struct BoxSdf : ICarveSdf
		{
			private readonly Vector3 c;

			private readonly Vector3 ax;

			private readonly Vector3 ay;

			private readonly Vector3 az;

			private readonly Vector3 half;

			private readonly float amp;

			private readonly float margin;

			private readonly float chunkR;

			private readonly float chunkWorld;

			private readonly uint seed;

			public BoxSdf(Vector3 c, Vector3 ax, Vector3 ay, Vector3 az, Vector3 half, float amp, float margin, float chunkR, float chunkWorld, uint seed)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//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_000f: 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_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				this.c = c;
				this.ax = ax;
				this.ay = ay;
				this.az = az;
				this.half = half;
				this.amp = amp;
				this.margin = margin;
				this.chunkR = chunkR;
				this.chunkWorld = chunkWorld;
				this.seed = seed;
			}

			private float BoxDist(Vector3 p)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = p - c;
				float num = Mathf.Abs(Vector3.Dot(val, ax)) - half.x;
				float num2 = Mathf.Abs(Vector3.Dot(val, ay)) - half.y;
				float num3 = Mathf.Abs(Vector3.Dot(val, az)) - half.z;
				float num4 = Mathf.Max(num, 0f);
				float num5 = Mathf.Max(num2, 0f);
				float num6 = Mathf.Max(num3, 0f);
				return Mathf.Sqrt(num4 * num4 + num5 * num5 + num6 * num6) + Mathf.Min(Mathf.Max(num, Mathf.Max(num2, num3)), 0f);
			}

			public float Distance(Vector3 p)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return BoxDist(p) - ShapeNoise(p, seed) * amp;
			}

			public bool SkipUnstoredChunk(int cx, int cy, int cz)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				return BoxDist(new Vector3((float)cx + 0.5f, (float)cy + 0.5f, (float)cz + 0.5f) * chunkWorld) > margin + chunkR;
			}
		}

		public const int N = 16;

		public const float Iso = 127.5f;

		private const bool RimEnabled = true;

		private const float RimWidthFrac = 0.35f;

		private const float RimPeak = 170f;

		private const float RimFullMassFrac = 0.5f;

		private const float RimMinMassFrac = 0.2f;

		public readonly float voxelSize;

		public readonly Dictionary<long, VoxelChunk> chunks = new Dictionary<long, VoxelChunk>();

		public Material material;

		public Material[] materials;

		public int dominantSub;

		public float carveScale = 1f;

		public bool openShell;

		public Bounds meshBoundsWS;

		public WindingField winding;

		public int index;

		public int priority;

		public Bounds boundsWS;

		public string name;

		public List<VoxelVolume> rivalCandidates;

		public int gMinX = int.MaxValue;

		public int gMinY = int.MaxValue;

		public int gMinZ = int.MaxValue;

		public int gMaxX = int.MinValue;

		public int gMaxY = int.MinValue;

		public int gMaxZ = int.MinValue;

		public int cMinX = int.MaxValue;

		public int cMinY = int.MaxValue;

		public int cMinZ = int.MaxValue;

		public int cMaxX = int.MinValue;

		public int cMaxY = int.MinValue;

		public int cMaxZ = int.MinValue;

		public SourceMesh source;

		public int lightmapIndex = -1;

		public Vector4 lightmapScaleOffset;

		public bool renderable = true;

		public ShadowCastingMode shadowMode = (ShadowCastingMode)1;

		private readonly Dictionary<long, List<ColumnEntry>> columns = new Dictionary<long, List<ColumnEntry>>();

		private readonly ConcurrentDictionary<long, bool> classifyCache = new ConcurrentDictionary<long, bool>();

		[ThreadStatic]
		private static List<RimWrite> rimScratch;

		private void TrackChunkRange(int cx, int cy, int cz)
		{
			if (cx < cMinX)
			{
				cMinX = cx;
			}
			if (cx > cMaxX)
			{
				cMaxX = cx;
			}
			if (cy < cMinY)
			{
				cMinY = cy;
			}
			if (cy > cMaxY)
			{
				cMaxY = cy;
			}
			if (cz < cMinZ)
			{
				cMinZ = cz;
			}
			if (cz > cMaxZ)
			{
				cMaxZ = cz;
			}
		}

		public VoxelVolume(float voxelSize)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			this.voxelSize = voxelSize;
		}

		public static long PackKey(int x, int y, int z)
		{
			return ((long)(x & 0x1FFFFF) << 42) | ((long)(y & 0x1FFFFF) << 21) | (z & 0x1FFFFF);
		}

		public static int UnpackSigned(long v)
		{
			int num = (int)(v & 0x1FFFFF);
			if (num < 1048576)
			{
				return num;
			}
			return num - 2097152;
		}

		public static float DistanceToBox(Vector3 p, Vector3 boxMin, Vector3 boxMax)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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)
			float num = Mathf.Max(new float[3]
			{
				boxMin.x - p.x,
				0f,
				p.x - boxMax.x
			});
			float num2 = Mathf.Max(new float[3]
			{
				boxMin.y - p.y,
				0f,
				p.y - boxMax.y
			});
			float num3 = Mathf.Max(new float[3]
			{
				boxMin.z - p.z,
				0f,
				p.z - boxMax.z
			});
			return Mathf.Sqrt(num * num + num2 * num2 + num3 * num3);
		}

		public VoxelChunk AddBandChunk(int cx, int cy, int cz, byte[] density)
		{
			VoxelChunk voxelChunk = new VoxelChunk
			{
				cx = cx,
				cy = cy,
				cz = cz,
				density = density
			};
			chunks[PackKey(cx, cy, cz)] = voxelChunk;
			TrackChunkRange(cx, cy, cz);
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < 16; i++)
			{
				for (int j = 0; j < 16; j++)
				{
					if ((float)(int)density[VoxelIndex(j, 15, i)] >= 127.5f)
					{
						num++;
					}
					if ((float)(int)density[VoxelIndex(j, 0, i)] >= 127.5f)
					{
						num2++;
					}
				}
			}
			long key = PackKey(cx, 0, cz);
			if (!columns.TryGetValue(key, out var value))
			{
				value = (columns[key] = new List<ColumnEntry>());
			}
			value.Add(new ColumnEntry
			{
				cy = cy,
				topSolid = (num * 2 > 256),
				bottomSolid = (num2 * 2 > 256)
			});
			return voxelChunk;
		}

		public void SortColumns()
		{
			foreach (List<ColumnEntry> value in columns.Values)
			{
				value.Sort((ColumnEntry a, ColumnEntry b) => a.cy.CompareTo(b.cy));
			}
		}

		public static int VoxelIndex(int x, int y, int z)
		{
			return (y * 16 + z) * 16 + x;
		}

		public bool ClassifySolid(int cx, int cy, int cz)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: 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_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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)
			if (openShell)
			{
				float num = 16f * voxelSize;
				Vector3 min = ((Bounds)(ref meshBoundsWS)).min;
				Vector3 max = ((Bounds)(ref meshBoundsWS)).max;
				if ((float)(cx + 1) * num < min.x || (float)cx * num > max.x || (float)(cy + 1) * num < min.y || (float)cy * num > max.y || (float)(cz + 1) * num < min.z || (float)cz * num > max.z)
				{
					return false;
				}
			}
			long key = PackKey(cx, cy, cz);
			if (classifyCache.TryGetValue(key, out var value))
			{
				return value;
			}
			bool flag = false;
			if (columns.TryGetValue(PackKey(cx, 0, cz), out var value2) && value2.Count > 0)
			{
				int num2 = -1;
				int num3 = -1;
				for (int i = 0; i < value2.Count; i++)
				{
					if (value2[i].cy < cy)
					{
						num2 = i;
					}
					else if (value2[i].cy > cy)
					{
						num3 = i;
						break;
					}
				}
				int num4 = ((num2 >= 0) ? (cy - value2[num2].cy) : int.MaxValue);
				int num5 = ((num3 >= 0) ? (value2[num3].cy - cy) : int.MaxValue);
				if (num4 <= num5 && num2 >= 0)
				{
					flag = value2[num2].topSolid;
				}
				else if (num3 >= 0)
				{
					flag = value2[num3].bottomSolid;
				}
			}
			if (flag && winding != null)
			{
				float num6 = 16f * voxelSize;
				float num7 = (float)cx * num6 + voxelSize;
				float num8 = (float)(cx + 1) * num6 - voxelSize;
				float num9 = (float)cy * num6 + voxelSize;
				float num10 = (float)(cy + 1) * num6 - voxelSize;
				float num11 = (float)cz * num6 + voxelSize;
				float num12 = (float)(cz + 1) * num6 - voxelSize;
				if ((winding.Query(new Vector3((num7 + num8) * 0.5f, (num9 + num10) * 0.5f, (num11 + num12) * 0.5f)) + (winding.Query(new Vector3(num7, num9, num11)) + winding.Query(new Vector3(num8, num9, num11)) + winding.Query(new Vector3(num7, num10, num11)) + winding.Query(new Vector3(num8, num10, num11)) + winding.Query(new Vector3(num7, num9, num12)) + winding.Query(new Vector3(num8, num9, num12)) + winding.Query(new Vector3(num7, num10, num12)) + winding.Query(new Vector3(num8, num10, num12)))) / 9f < 0.35f)
				{
					flag = false;
				}
			}
			classifyCache[key] = flag;
			return flag;
		}

		public byte Sample(int ix, int iy, int iz)
		{
			int num = ix >> 4;
			int num2 = iy >> 4;
			int num3 = iz >> 4;
			if (chunks.TryGetValue(PackKey(num, num2, num3), out var value) && value.density != null)
			{
				return value.density[VoxelIndex(ix & 0xF, iy & 0xF, iz & 0xF)];
			}
			if (!ClassifySolid(num, num2, num3))
			{
				return 0;
			}
			return byte.MaxValue;
		}

		public byte SampleCached(int ix, int iy, int iz, ref long lastKey, ref VoxelChunk lastChunk, ref byte lastSolid)
		{
			int num = ix >> 4;
			int num2 = iy >> 4;
			int num3 = iz >> 4;
			long num4 = PackKey(num, num2, num3);
			if (num4 != lastKey)
			{
				lastKey = num4;
				chunks.TryGetValue(num4, out lastChunk);
				if (lastChunk == null || lastChunk.density == null)
				{
					lastChunk = null;
					lastSolid = (byte)(ClassifySolid(num, num2, num3) ? byte.MaxValue : 0);
				}
			}
			if (lastChunk == null)
			{
				return lastSolid;
			}
			return lastChunk.density[VoxelIndex(ix & 0xF, iy & 0xF, iz & 0xF)];
		}

		public Vector3 VoxelCenter(int ix, int iy, int iz)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(((float)ix + 0.5f) * voxelSize, ((float)iy + 0.5f) * voxelSize, ((float)iz + 0.5f) * voxelSize);
		}

		public float Carve(Vector3 pos, float r, uint seed, HashSet<long> dirtyOut, bool rim = true)
		{
			//IL_0016: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_00a5: 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_018d: 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_01bd: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: 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_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: 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)
			float num = Mathf.Min(1.5f, r * 0.15f);
			float num2 = r + num;
			int x = Mathf.FloorToInt((pos.x - num2) / voxelSize) - 1;
			int x2 = Mathf.FloorToInt((pos.x + num2) / voxelSize) + 1;
			int y = Mathf.FloorToInt((pos.y - num2) / voxelSize) - 1;
			int y2 = Mathf.FloorToInt((pos.y + num2) / voxelSize) + 1;
			int z = Mathf.FloorToInt((pos.z - num2) / voxelSize) - 1;
			int z2 = Mathf.FloorToInt((pos.z + num2) / voxelSize) + 1;
			float num3 = CarveKernel<SphereSdf>(new SphereSdf(pos, r, num, num2, seed, 16f * voxelSize), x, y, z, x2, y2, z2, dirtyOut);
			float num4 = 4.18879f * (r / voxelSize) * (r / voxelSize) * (r / voxelSize);
			float num5 = ((num4 > 0f) ? Mathf.Clamp01(num3 / (0.5f * num4)) : 0f);
			if (rim && num5 >= 0.2f)
			{
				float num6 = 170f * num5;
				float num7 = Mathf.Clamp(r * 0.35f, voxelSize, 3f);
				List<RimWrite> list = rimScratch ?? (rimScratch = new List<RimWrite>(256));
				list.Clear();
				float num8 = num2 + num7;
				int num9 = Mathf.FloorToInt((pos.x - num8) / voxelSize) - 1;
				int num10 = Mathf.FloorToInt((pos.x + num8) / voxelSize) + 1;
				int num11 = Mathf.FloorToInt((pos.y - num8) / voxelSize) - 1;
				int num12 = Mathf.FloorToInt((pos.y + num8) / voxelSize) + 1;
				int num13 = Mathf.FloorToInt((pos.z - num8) / voxelSize) - 1;
				int num14 = Mathf.FloorToInt((pos.z + num8) / voxelSize) + 1;
				long lastKey = long.MinValue;
				long lastKey2 = long.MinValue;
				VoxelChunk lastChunk = null;
				VoxelChunk lastChunk2 = null;
				byte lastSolid = 0;
				byte lastSolid2 = 0;
				for (int i = num11; i <= num12; i++)
				{
					for (int j = num13; j <= num14; j++)
					{
						for (int k = num9; k <= num10; k++)
						{
							Vector3 val = VoxelCenter(k, i, j);
							Vector3 val2 = val - pos;
							float num15 = ((Vector3)(ref val2)).magnitude - (r + ShapeNoise(val, seed) * num);
							if (num15 <= 0f || num15 >= num7)
							{
								continue;
							}
							byte b = SampleCached(k, i, j, ref lastKey, ref lastChunk, ref lastSolid);
							if (!((float)(int)b >= 127.5f) && !((float)(int)SampleCached(k, i - 1, j, ref lastKey2, ref lastChunk2, ref lastSolid2) < 127.5f))
							{
								int num16 = (int)(num6 * Mathf.Sin(MathF.PI * num15 / num7));
								if (num16 > 0)
								{
									list.Add(new RimWrite
									{
										ix = k,
										iy = i,
										iz = j,
										val = (byte)Mathf.Min(b + num16, 255)
									});
								}
							}
						}
					}
				}
				long num17 = long.MinValue;
				VoxelChunk value = null;
				foreach (RimWrite item in list)
				{
					int num18 = item.ix >> 4;
					int num19 = item.iy >> 4;
					int num20 = item.iz >> 4;
					long num21 = PackKey(num18, num19, num20);
					if (num21 != num17)
					{
						num17 = num21;
						if (!chunks.TryGetValue(num21, out value) || value.density == null)
						{
							value = MaterializeAir(num18, num19, num20);
						}
					}
					int num22 = item.ix & 0xF;
					int num23 = item.iy & 0xF;
					int num24 = item.iz & 0xF;
					MarkDirty(dirtyOut, num18, num19, num20, num22, num23, num24, num22, num23, num24);
					value.density[VoxelIndex(num22, num23, num24)] = item.val;
				}
			}
			return num3;
		}

		private static void MarkDirty(HashSet<long> dirtyOut, int cx, int cy, int cz, int lx0, int ly0, int lz0, int lx1, int ly1, int lz1)
		{
			int num = ((lx0 < 2) ? (-1) : 0);
			int num2 = ((lx1 >= 14) ? 1 : 0);
			int num3 = ((ly0 < 2) ? (-1) : 0);
			int num4 = ((ly1 >= 14) ? 1 : 0);
			int num5 = ((lz0 < 2) ? (-1) : 0);
			int num6 = ((lz1 >= 14) ? 1 : 0);
			for (int i = num; i <= num2; i++)
			{
				for (int j = num3; j <= num4; j++)
				{
					for (int k = num5; k <= num6; k++)
					{
						dirtyOut.Add(PackKey(cx + i, cy + j, cz + k));
					}
				}
			}
		}

		public float CarveBox(Vector3 c, Vector3 ax, Vector3 ay, Vector3 az, Vector3 half, uint seed, HashSet<long> dirtyOut)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0092: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_0112: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: 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_0171: 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)
			float num = 0.15f + voxelSize;
			float num2 = half.x * Mathf.Abs(ax.x) + half.y * Mathf.Abs(ay.x) + half.z * Mathf.Abs(az.x) + num;
			float num3 = half.x * Mathf.Abs(ax.y) + half.y * Mathf.Abs(ay.y) + half.z * Mathf.Abs(az.y) + num;
			float num4 = half.x * Mathf.Abs(ax.z) + half.y * Mathf.Abs(ay.z) + half.z * Mathf.Abs(az.z) + num;
			int x = Mathf.FloorToInt((c.x - num2) / voxelSize) - 1;
			int x2 = Mathf.FloorToInt((c.x + num2) / voxelSize) + 1;
			int y = Mathf.FloorToInt((c.y - num3) / voxelSize) - 1;
			int y2 = Mathf.FloorToInt((c.y + num3) / voxelSize) + 1;
			int z = Mathf.FloorToInt((c.z - num4) / voxelSize) - 1;
			int z2 = Mathf.FloorToInt((c.z + num4) / voxelSize) + 1;
			float chunkR = 16f * voxelSize * 0.87f;
			return CarveKernel<BoxSdf>(new BoxSdf(c, ax, ay, az, half, 0.15f, num, chunkR, 16f * voxelSize, seed), x, y, z, x2, y2, z2, dirtyOut);
		}

		private float CarveKernel<T>(in T sdf, int x0, int y0, int z0, int x1, int y1, int z1, HashSet<long> dirtyOut) where T : struct, ICarveSdf
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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)
			float num = 0f;
			for (int i = x0 >> 4; i <= x1 >> 4; i++)
			{
				for (int j = y0 >> 4; j <= y1 >> 4; j++)
				{
					for (int k = z0 >> 4; k <= z1 >> 4; k++)
					{
						long key = PackKey(i, j, k);
						if (!chunks.TryGetValue(key, out var value) || value.density == null)
						{
							if (!ClassifySolid(i, j, k) || sdf.SkipUnstoredChunk(i, j, k))
							{
								continue;
							}
							value = MaterializeSolid(i, j, k);
						}
						bool flag = false;
						byte[] density = value.density;
						int num2 = 16;
						int num3 = 16;
						int num4 = 16;
						int num5 = -1;
						int num6 = -1;
						int num7 = -1;
						int num8 = Mathf.Max(x0, i << 4);
						int num9 = Mathf.Min(x1, (i << 4) + 16 - 1);
						int num10 = Mathf.Max(y0, j << 4);
						int num11 = Mathf.Min(y1, (j << 4) + 16 - 1);
						int num12 = Mathf.Max(z0, k << 4);
						int num13 = Mathf.Min(z1, (k << 4) + 16 - 1);
						for (int l = num10; l <= num11; l++)
						{
							for (int m = num12; m <= num13; m++)
							{
								for (int n = num8; n <= num9; n++)
								{
									int num14 = n & 0xF;
									int num15 = l & 0xF;
									int num16 = m & 0xF;
									int num17 = VoxelIndex(num14, num15, num16);
									byte b = density[num17];
									if (b == 0)
									{
										continue;
									}
									Vector3 p = VoxelCenter(n, l, m);
									float num18 = sdf.Distance(p);
									float num19 = Mathf.Clamp01(0.5f + num18 / voxelSize) * 255f;
									if (num19 < (float)(int)b)
									{
										num += (float)(b - (density[num17] = (byte)num19)) / 255f;
										flag = true;
										if (num14 < num2)
										{
											num2 = num14;
										}
										if (num14 > num5)
										{
											num5 = num14;
										}
										if (num15 < num3)
										{
											num3 = num15;
										}
										if (num15 > num6)
										{
											num6 = num15;
										}
										if (num16 < num4)
										{
											num4 = num16;
										}
										if (num16 > num7)
										{
											num7 = num16;
										}
									}
								}
							}
						}
						if (flag)
						{
							MarkDirty(dirtyOut, i, j, k, num2, num3, num4, num5, num6, num7);
						}
					}
				}
			}
			return num;
		}

		private VoxelChunk MaterializeSolid(int cx, int cy, int cz)
		{
			byte[] array = new byte[4096];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = byte.MaxValue;
			}
			VoxelChunk voxelChunk = new VoxelChunk
			{
				cx = cx,
				cy = cy,
				cz = cz,
				density = array
			};
			chunks[PackKey(cx, cy, cz)] = voxelChunk;
			TrackChunkRange(cx, cy, cz);
			return voxelChunk;
		}

		private VoxelChunk MaterializeAir(int cx, int cy, int cz)
		{
			VoxelChunk voxelChunk = new VoxelChunk
			{
				cx = cx,
				cy = cy,
				cz = cz,
				density = new byte[4096]
			};
			chunks[PackKey(cx, cy, cz)] = voxelChunk;
			TrackChunkRange(cx, cy, cz);
			return voxelChunk;
		}

		private static float Hash3(int x, int y, int z, uint seed)
		{
			int num = (x * 73856093) ^ (y * 19349663) ^ (z * 83492791) ^ ((int)seed * -1640531527);
			int num2 = (num ^ (num >>> 13)) * -2048144789;
			return (float)(uint)((num2 ^ (num2 >>> 16)) & 0xFFFFFF) / (26353588f / MathF.PI) - 1f;
		}

		public static float ShapeNoise(Vector3 p, uint seed)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			float num = Hash3(Mathf.RoundToInt(p.x * 2f), Mathf.RoundToInt(p.y * 2f), Mathf.RoundToInt(p.z * 2f), seed);
			float num2 = Hash3(Mathf.FloorToInt(p.x * 0.5f), Mathf.FloorToInt(p.y * 0.5f), Mathf.FloorToInt(p.z * 0.5f), seed * 7919 + 1);
			return num * 0.5f + num2 * 0.5f;
		}
	}
	internal class VoxelChunk
	{
		public int cx;

		public int cy;

		public int cz;

		public byte[] density;

		public int[] srcTris;

		public GameObject go;

		public Mesh mesh;

		public MeshFilter filter;

		public MeshRenderer renderer;

		public MeshCollider collider;

		public bool hasSurface;

		public volatile bool bakeInFlight;
	}
	internal class WindingField
	{
		private struct Node
		{
			public Vector3 dipole;

			public Vector3 center;

			public float radius;

			public int left;

			public int right;

			public int start;

			public int count;
		}

		private class CentroidComparer : IComparer<int>
		{
			private readonly Vector3[] centroid;

			private readonly int axis;

			public CentroidComparer(Vector3[] centroid, int axis)
			{
				this.centroid = centroid;
				this.axis = axis;
			}

			public int Compare(int x, int y)
			{
				float num = ((Vector3)(ref centroid[x]))[axis];
				float num2 = ((Vector3)(ref centroid[y]))[axis];
				if (num != num2)
				{
					if (!(num < num2))
					{
						return 1;
					}
					return -1;
				}
				return x.CompareTo(y);
			}
		}

		private const int LeafSize = 8;

		private const float Beta = 2f;

		private readonly Node[] nodes;

		private readonly Vector3[] ta;

		private readonly Vector3[] tb;

		private readonly Vector3[] tc;

		private float sign = 1f;

		public long ApproxBytes => ((nodes != null) ? ((long)nodes.Length * 44L) : 0) + ((ta != null) ? ((long)ta.Length * 36L) : 0);

		public void MarkFlipped()
		{
			sign = 0f - sign;
		}

		public WindingField(Vector3[] verts, int[] indices)
		{
			//IL_003a: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: 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_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: 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_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			int num = indices.Length / 3;
			Vector3[] array = (Vector3[])(object)new Vector3[num];
			int[] array2 = new int[num];
			for (int i = 0; i < num; i++)
			{
				array2[i] = i;
				array[i] = (verts[indices[i * 3]] + verts[indices[i * 3 + 1]] + verts[indices[i * 3 + 2]]) / 3f;
			}
			List<Node> list = new List<Node>(num / 2 + 1);
			BuildNode(array2, 0, num, array, list);
			nodes = list.ToArray();
			ta = (Vector3[])(object)new Vector3[num];
			tb = (Vector3[])(object)new Vector3[num];
			tc = (Vector3[])(object)new Vector3[num];
			for (int j = 0; j < num; j++)
			{
				int num2 = array2[j] * 3;
				ta[j] = verts[indices[num2]];
				tb[j] = verts[indices[num2 + 1]];
				tc[j] = verts[indices[num2 + 2]];
			}
			for (int num3 = nodes.Length - 1; num3 >= 0; num3--)
			{
				Node node = nodes[num3];
				Vector3 val4;
				if (node.left < 0)
				{
					Vector3 val = Vector3.zero;
					Vector3 val2 = Vector3.zero;
					float num4 = 0f;
					for (int k = node.start; k < node.start + node.count; k++)
					{
						Vector3 val3 = Vector3.Cross(tb[k] - ta[k], tc[k] - ta[k]);
						val += val3 * 0.5f;
						float num5 = ((Vector3)(ref val3)).magnitude * 0.5f + 1E-09f;
						val2 += (ta[k] + tb[k] + tc[k]) / 3f * num5;
						num4 += num5;
					}
					node.dipole = val;
					node.center = val2 / num4;
					float num6 = 0f;
					for (int l = node.start; l < node.start + node.count; l++)
					{
						float num7 = num6;
						val4 = ta[l] - node.center;
						num6 = Mathf.Max(num7, ((Vector3)(ref val4)).sqrMagnitude);
						float num8 = num6;
						val4 = tb[l] - node.center;
						num6 = Mathf.Max(num8, ((Vector3)(ref val4)).sqrMagnitude);
						float num9 = num6;
						val4 = tc[l] - node.center;
						num6 = Mathf.Max(num9, ((Vector3)(ref val4)).sqrMagnitude);
					}
					node.radius = Mathf.Sqrt(num6);
				}
				else
				{
					Node node2 = nodes[node.left];
					Node node3 = nodes[node.right];
					node.dipole = node2.dipole + node3.dipole;
					node.center = (node2.center + node3.center) * 0.5f;
					val4 = node2.center - node.center;
					float num10 = ((Vector3)(ref val4)).magnitude + node2.radius;
					val4 = node3.center - node.center;
					node.radius = Mathf.Max(num10, ((Vector3)(ref val4)).magnitude + node3.radius);
				}
				nodes[num3] = node;
			}
		}

		private static int BuildNode(int[] order, int start, int count, Vector3[] centroid, List<Node> nodeList)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_0095: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			int count2 = nodeList.Count;
			nodeList.Add(default(Node));
			if (count <= 8)
			{
				nodeList[count2] = new Node
				{
					left = -1,
					right = -1,
					start = start,
					count = count
				};
				return count2;
			}
			Vector3 val = centroid[order[start]];
			Vector3 val2 = val;
			for (int i = start + 1; i < start + count; i++)
			{
				val = Vector3.Min(val, centroid[order[i]]);
				val2 = Vector3.Max(val2, centroid[order[i]]);
			}
			Vector3 val3 = val2 - val;
			int axis = ((!(val3.x >= val3.y)) ? ((val3.y >= val3.z) ? 1 : 2) : ((!(val3.x >= val3.z)) ? 2 : 0));
			Array.Sort(order, start, count, new CentroidComparer(centroid, axis));
			int num = count / 2;
			int left = BuildNode(order, start, num, centroid, nodeList);
			int right = BuildNode(order, start + num, count - num, centroid, nodeList);
			nodeList[count2] = new Node
			{
				left = left,
				right = right
			};
			return count2;
		}

		public float Query(Vector3 p)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0145: 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_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_01ed: 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)
			double num = 0.0;
			Span<int> span = stackalloc int[64];
			int num2 = 0;
			span[num2++] = 0;
			while (num2 > 0)
			{
				ref Node reference = ref nodes[span[--num2]];
				float num3 = reference.center.x - p.x;
				float num4 = reference.center.y - p.y;
				float num5 = reference.center.z - p.z;
				float num6 = num3 * num3 + num4 * num4 + num5 * num5;
				float num7 = 2f * reference.radius;
				if (num6 > num7 * num7)
				{
					double num8 = Math.Sqrt(num6);
					num += (double)(reference.dipole.x * num3 + reference.dipole.y * num4 + reference.dipole.z * num5) / (Math.PI * 4.0 * (double)num6 * num8);
				}
				else if (reference.left < 0)
				{
					for (int i = reference.start; i < reference.start + reference.count; i++)
					{
						double num9 = ta[i].x - p.x;
						double num10 = ta[i].y - p.y;
						double num11 = ta[i].z - p.z;
						double num12 = tb[i].x - p.x;
						double num13 = tb[i].y - p.y;
						double num14 = tb[i].z - p.z;
						double num15 = tc[i].x - p.x;
						double num16 = tc[i].y - p.y;
						double num17 = tc[i].z - p.z;
						double num18 = Math.Sqrt(num9 * num9 + num10 * num10 + num11 * num11);
						double num19 = Math.Sqrt(num12 * num12 + num13 * num13 + num14 * num14);
						double num20 = Math.Sqrt(num15 * num15 + num16 * num16 + num17 * num17);
						double y = num9 * (num13 * num17 - num14 * num16) - num10 * (num12 * num17 - num14 * num15) + num11 * (num12 * num16 - num13 * num15);
						double x = num18 * num19 * num20 + (num9 * num12 + num10 * num13 + num11 * num14) * num20 + (num12 * num15 + num13 * num16 + num14 * num17) * num18 + (num15 * num9 + num16 * num10 + num17 * num11) * num19;
						num += Math.Atan2(y, x) / (Math.PI * 2.0);
					}
				}
				else
				{
					span[num2++] = reference.left;
					span[num2++] = reference.right;
				}
			}
			return (float)num * sign;
		}

		public (int up, int down) NodeStandingEvidence(Vector3[] groundNodes)
		{
			//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)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (groundNodes == null || groundNodes.Length == 0)
			{
				return (up: 0, down: 0);
			}
			int num = 0;
			int num2 = 0;
			int num3 = Math.Max(1, groundNodes.Length / 400);
			for (int i = 0; i < groundNodes.Length; i += num3)
			{
				Vector3 p = groundNodes[i];
				p.y += 1.5f;
				float num4 = FirstHitDownNormalY(p, 6.5f);
				if (num4 > 0.1f)
				{
					num++;
				}
				else if (num4 < -0.1f)
				{
					num2++;
				}
			}
			return (up: num, down: num2);
		}

		private float FirstHitDownNormalY(Vector3 p, float maxDrop)
		{
			//IL_0020: 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_006d: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0113: 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_0122: 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_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: 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_0266: 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_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			Span<int> span = stackalloc int[64];
			int num = 0;
			span[num++] = 0;
			float num2 = p.y - maxDrop;
			float num3 = 0f;
			while (num > 0)
			{
				ref Node reference = ref nodes[span[--num]];
				float num4 = reference.center.x - p.x;
				float num5 = reference.center.z - p.z;
				if (num4 * num4 + num5 * num5 > reference.radius * reference.radius || reference.center.y - reference.radius > p.y || reference.center.y + reference.radius < num2)
				{
					continue;
				}
				if (reference.left < 0)
				{
					for (int i = reference.start; i < reference.start + reference.count; i++)
					{
						Vector3 val = ta[i];
						Vector3 val2 = tb[i];
						Vector3 val3 = tc[i];
						double num6 = (val2.z - val3.z) * (val.x - val3.x) + (val3.x - val2.x) * (val.z - val3.z);
						if (Math.Abs(num6) < 1E-12)
						{
							continue;
						}
						double num7 = (double)((val2.z - val3.z) * (p.x - val3.x) + (val3.x - val2.x) * (p.z - val3.z)) / num6;
						if (num7 < -1E-06)
						{
							continue;
						}
						double num8 = (double)((val3.z - val.z) * (p.x - val3.x) + (val.x - val3.x) * (p.z - val3.z)) / num6;
						if (num8 < -1E-06 || num7 + num8 > 1.000001)
						{
							continue;
						}
						float num9 = (float)(num7 * (double)val.y + num8 * (double)val2.y + (1.0 - num7 - num8) * (double)val3.y);
						if (!(num9 > p.y) && !(num9 <= num2))
						{
							Vector3 val4 = Vector3.Cross(val2 - val, val3 - val);
							float magnitude = ((Vector3)(ref val4)).magnitude;
							if (!(magnitude < 1E-12f))
							{
								num2 = num9;
								num3 = val4.y / magnitude;
							}
						}
					}
				}
				else
				{
					span[num++] = reference.left;
					span[num++] = reference.right;
				}
			}
			return num3 * sign;
		}
	}
}