using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BombCollar;
using CodeRebirth.src.Content.Enemies;
using CodeRebirth.src.Content.Maps;
using CodeRebirth.src.MiscScripts;
using Dawn;
using Dawn.Utils;
using DiversityRemastered;
using DiversityRemastered.Misc;
using GameNetcodeStuff;
using HarmonyLib;
using JetBrains.Annotations;
using KaimiraGames;
using LethalCompanyInputUtils.Api;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LethalLib.Extras;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using MoreCompany.Cosmetics;
using MysteryDice;
using MysteryDice.CompatThings;
using MysteryDice.Dice;
using MysteryDice.Effects;
using MysteryDice.Extensions;
using MysteryDice.Gal;
using MysteryDice.MiscStuff;
using MysteryDice.NetcodePatcher;
using MysteryDice.Patches;
using MysteryDice.Visual;
using Newtonsoft.Json;
using PathfindingLib.Jobs;
using PathfindingLib.Utilities;
using Surfaced;
using TMPro;
using TooManyEmotes;
using TooManyEmotes.Props;
using TooManyEmotes.UI;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.AI;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("CodeRebirth")]
[assembly: IgnoresAccessChecksTo("Surfaced")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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;
		}
	}
}
public class TargetRandomPlayer : MonoBehaviour
{
	private NavMeshAgent agent;

	private PlayerControllerB target;

	public void Start()
	{
		agent = ((Component)this).gameObject.GetComponent<NavMeshAgent>();
		target = Misc.GetRandomAlivePlayer();
	}

	public void Update()
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)target == (Object)null || target.isPlayerDead)
		{
			target = Misc.GetRandomAlivePlayer();
		}
		agent.SetDestination(((Component)target).transform.position);
	}
}
public class Blinking : MonoBehaviour
{
	public float BlinkingTime;

	private float BlinkingTimer = 0f;

	private GameObject GlowSign;

	private GameObject NormalSign;

	private bool Stop = false;

	public bool Glow { get; private set; }

	private void Start()
	{
		BlinkingTime = 0.5f;
		Glow = false;
		NormalSign = ((Component)((Component)this).transform.Find("Emergency Sign")).gameObject;
		GlowSign = ((Component)((Component)this).transform.Find("Emergency Sign Glowing")).gameObject;
	}

	public void HideSigns()
	{
		Stop = true;
		NormalSign.SetActive(false);
		GlowSign.SetActive(false);
	}

	private void Update()
	{
		if (Stop)
		{
			return;
		}
		BlinkingTimer -= Time.deltaTime;
		if (BlinkingTimer <= 0f)
		{
			BlinkingTimer = BlinkingTime;
			if (Glow)
			{
				Glow = false;
				NormalSign.SetActive(true);
				GlowSign.SetActive(false);
			}
			else
			{
				Glow = true;
				NormalSign.SetActive(false);
				GlowSign.SetActive(true);
			}
		}
	}
}
public class ColorGradient : MonoBehaviour
{
	public Renderer CubeRenderer;

	public Renderer MoonRenderer;

	public Renderer SunRenderer;

	public Color NightColor = new Color(0.40392157f, 33f / 85f, 0.8862745f);

	public Color DayColor = new Color(1f, 0.81960785f, 0f);

	private float ColorTimer = 0f;

	private void Start()
	{
		CubeRenderer = ((Component)this).GetComponent<Renderer>();
		SunRenderer = ((Component)((Component)this).transform.Find("Sun")).GetComponent<Renderer>();
		MoonRenderer = ((Component)((Component)this).transform.Find("Moon")).GetComponent<Renderer>();
	}

	private void Update()
	{
		//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_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_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_0062: 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_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_00ce: 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_0124: 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_017a: 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)
		ColorTimer -= Time.deltaTime;
		if (!(ColorTimer >= 0f))
		{
			ColorTimer = 1f;
			Color val = DayColor + (NightColor - DayColor) * TimeOfDay.Instance.normalizedTimeOfDay;
			CubeRenderer.material.SetColor("_BaseColor", val);
			CubeRenderer.material.SetColor("_EmissiveColor", val * 3f);
			float normalizedTimeOfDay = TimeOfDay.Instance.normalizedTimeOfDay;
			float num = 1f - normalizedTimeOfDay;
			MoonRenderer.material.SetColor("_BaseColor", new Color(1f, 1f, 1f, normalizedTimeOfDay));
			SunRenderer.material.SetColor("_BaseColor", new Color(1f, 1f, 1f, num));
			MoonRenderer.material.SetColor("_UnlitColor", new Color(1f, 1f, 1f, normalizedTimeOfDay));
			SunRenderer.material.SetColor("_UnlitColor", new Color(1f, 1f, 1f, num));
			MoonRenderer.material.SetColor("_MainColor", new Color(1f, 1f, 1f, normalizedTimeOfDay));
			SunRenderer.material.SetColor("_MainColor", new Color(1f, 1f, 1f, num));
		}
	}
}
public class CycleSigns : MonoBehaviour
{
	private class DiceVisuals
	{
		public Sprite Sprite;

		public Color ModelColor;

		public Color EmissionColor;

		public float Emission;

		public DiceVisuals(Sprite sprite, Color color, Color emissionColor, float emission)
		{
			//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_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)
			Sprite = sprite;
			ModelColor = color;
			EmissionColor = emissionColor;
			Emission = emission;
		}
	}

	public float CycleTime = 1f;

	private float CurrentTimer = 0f;

	private int CurrentSprite = 0;

	private bool Stop = false;

	private SpriteRenderer SignSpriteRenderer;

	private SpriteRenderer SignSpriteRenderer2;

	private Renderer DiceRenderer;

	private List<DiceVisuals> Visuals = new List<DiceVisuals>();

	private void Start()
	{
		//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_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_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_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)
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningJester, Color.yellow, Color.yellow, 100f));
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningBracken, Color.yellow, Color.yellow, 100f));
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningDeath, Color.red, Color.red, 100f));
		Visuals.Add(new DiceVisuals(global::MysteryDice.MysteryDice.WarningLuck, Color.green, Color.green, 300f));
		SignSpriteRenderer = ((Component)((Component)this).transform.Find("Emergency Sign")).gameObject.GetComponent<SpriteRenderer>();
		SignSpriteRenderer2 = ((Component)((Component)this).transform.Find("Emergency Sign2")).gameObject.GetComponent<SpriteRenderer>();
		DiceRenderer = ((Component)this).gameObject.GetComponent<Renderer>();
	}

	private void Update()
	{
		if (!Stop)
		{
			CurrentTimer -= Time.deltaTime;
			if (CurrentTimer <= 0f)
			{
				CurrentTimer = CycleTime;
				CycleSprite();
			}
		}
	}

	private void CycleSprite()
	{
		//IL_0095: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
		CurrentSprite++;
		if (CurrentSprite >= Visuals.Count)
		{
			CurrentSprite = 0;
		}
		SignSpriteRenderer.sprite = Visuals[CurrentSprite].Sprite;
		SignSpriteRenderer2.sprite = Visuals[CurrentSprite].Sprite;
		DiceRenderer.material.SetColor("_BaseColor", Visuals[CurrentSprite].ModelColor);
		DiceRenderer.material.SetColor("_EmissiveColor", Visuals[CurrentSprite].EmissionColor * Visuals[CurrentSprite].Emission);
	}

	public void HideSigns()
	{
		Stop = true;
		((Renderer)((Component)SignSpriteRenderer).GetComponent<SpriteRenderer>()).enabled = false;
		((Renderer)((Component)SignSpriteRenderer2).GetComponent<SpriteRenderer>()).enabled = false;
	}
}
namespace KaimiraGames
{
	public class WeightedList<T> : IEnumerable<T>, IEnumerable
	{
		private readonly List<T> _list = new List<T>();

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

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

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

		private readonly Random _rand;

		private int _totalWeight;

		private bool _areAllProbabilitiesIdentical = false;

		private int _minWeight;

		private int _maxWeight;

		public WeightErrorHandlingType BadWeightErrorHandling { get; set; } = WeightErrorHandlingType.SetWeightToOne;

		public int TotalWeight => _totalWeight;

		public int MinWeight => _minWeight;

		public int MaxWeight => _maxWeight;

		public IReadOnlyList<T> Items => _list.AsReadOnly();

		public T this[int index] => _list[index];

		public int Count => _list.Count;

		public WeightedList(Random rand = null)
		{
			_rand = rand ?? new Random();
		}

		public WeightedList(ICollection<WeightedListItem<T>> listItems, Random rand = null)
		{
			_rand = rand ?? new Random();
			foreach (WeightedListItem<T> listItem in listItems)
			{
				_list.Add(listItem._item);
				_weights.Add(listItem._weight);
			}
			Recalculate();
		}

		public T Next()
		{
			if (Count == 0)
			{
				return default(T);
			}
			int index = _rand.Next(Count);
			if (_areAllProbabilitiesIdentical)
			{
				return _list[index];
			}
			int num = _rand.Next(_totalWeight);
			return (num < _probabilities[index]) ? _list[index] : _list[_alias[index]];
		}

		public void AddWeightToAll(int weight)
		{
			if (weight + _minWeight <= 0 && BadWeightErrorHandling == WeightErrorHandlingType.ThrowExceptionOnAdd)
			{
				throw new ArgumentException($"Subtracting {-1 * weight} from all items would set weight to non-positive for at least one element.");
			}
			for (int i = 0; i < Count; i++)
			{
				_weights[i] = FixWeight(_weights[i] + weight);
			}
			Recalculate();
		}

		public void SubtractWeightFromAll(int weight)
		{
			AddWeightToAll(weight * -1);
		}

		public void SetWeightOfAll(int weight)
		{
			if (weight <= 0 && BadWeightErrorHandling == WeightErrorHandlingType.ThrowExceptionOnAdd)
			{
				throw new ArgumentException("Weight cannot be non-positive.");
			}
			for (int i = 0; i < Count; i++)
			{
				_weights[i] = FixWeight(weight);
			}
			Recalculate();
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		public void Add(T item, int weight)
		{
			_list.Add(item);
			_weights.Add(FixWeight(weight));
			Recalculate();
		}

		public void Add(ICollection<WeightedListItem<T>> listItems)
		{
			foreach (WeightedListItem<T> listItem in listItems)
			{
				_list.Add(listItem._item);
				_weights.Add(FixWeight(listItem._weight));
			}
			Recalculate();
		}

		public void Clear()
		{
			_list.Clear();
			_weights.Clear();
			Recalculate();
		}

		public void Contains(T item)
		{
			_list.Contains(item);
		}

		public int IndexOf(T item)
		{
			return _list.IndexOf(item);
		}

		public void Insert(int index, T item, int weight)
		{
			_list.Insert(index, item);
			_weights.Insert(index, FixWeight(weight));
			Recalculate();
		}

		public void Remove(T item)
		{
			int index = IndexOf(item);
			RemoveAt(index);
			Recalculate();
		}

		public void RemoveAt(int index)
		{
			_list.RemoveAt(index);
			_weights.RemoveAt(index);
			Recalculate();
		}

		public void SetWeight(T item, int newWeight)
		{
			SetWeightAtIndex(IndexOf(item), FixWeight(newWeight));
		}

		public int GetWeightOf(T item)
		{
			return GetWeightAtIndex(IndexOf(item));
		}

		public void SetWeightAtIndex(int index, int newWeight)
		{
			_weights[index] = FixWeight(newWeight);
			Recalculate();
		}

		public int GetWeightAtIndex(int index)
		{
			return _weights[index];
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("WeightedList<");
			stringBuilder.Append(typeof(T).Name);
			stringBuilder.Append(">: TotalWeight:");
			stringBuilder.Append(TotalWeight);
			stringBuilder.Append(", Min:");
			stringBuilder.Append(_minWeight);
			stringBuilder.Append(", Max:");
			stringBuilder.Append(_maxWeight);
			stringBuilder.Append(", Count:");
			stringBuilder.Append(Count);
			stringBuilder.Append(", {");
			for (int i = 0; i < _list.Count; i++)
			{
				stringBuilder.Append(_list[i].ToString());
				stringBuilder.Append(":");
				stringBuilder.Append(_weights[i].ToString());
				if (i < _list.Count - 1)
				{
					stringBuilder.Append(", ");
				}
			}
			stringBuilder.Append("}");
			return stringBuilder.ToString();
		}

		private void Recalculate()
		{
			_totalWeight = 0;
			_areAllProbabilitiesIdentical = false;
			_minWeight = 0;
			_maxWeight = 0;
			bool flag = true;
			_alias.Clear();
			_probabilities.Clear();
			List<int> list = new List<int>(Count);
			List<int> list2 = new List<int>(Count);
			List<int> list3 = new List<int>(Count);
			foreach (int weight in _weights)
			{
				if (flag)
				{
					_minWeight = (_maxWeight = weight);
					flag = false;
				}
				_minWeight = ((weight < _minWeight) ? weight : _minWeight);
				_maxWeight = ((_maxWeight < weight) ? weight : _maxWeight);
				_totalWeight += weight;
				list.Add(weight * Count);
				_alias.Add(0);
				_probabilities.Add(0);
			}
			if (_minWeight == _maxWeight)
			{
				_areAllProbabilitiesIdentical = true;
				return;
			}
			for (int i = 0; i < Count; i++)
			{
				if (list[i] < _totalWeight)
				{
					list2.Add(i);
				}
				else
				{
					list3.Add(i);
				}
			}
			while (list2.Count > 0 && list3.Count > 0)
			{
				int index = list2[list2.Count - 1];
				list2.RemoveAt(list2.Count - 1);
				int num = list3[list3.Count - 1];
				list3.RemoveAt(list3.Count - 1);
				_probabilities[index] = list[index];
				_alias[index] = num;
				int num2 = (list[num] = list[num] + list[index] - _totalWeight);
				if (num2 < _totalWeight)
				{
					list2.Add(num);
				}
				else
				{
					list3.Add(num);
				}
			}
			while (list3.Count > 0)
			{
				int index2 = list3[list3.Count - 1];
				list3.RemoveAt(list3.Count - 1);
				_probabilities[index2] = _totalWeight;
			}
		}

		internal static int FixWeightSetToOne(int weight)
		{
			return (weight <= 0) ? 1 : weight;
		}

		internal static int FixWeightExceptionOnAdd(int weight)
		{
			if (weight > 0)
			{
				return weight;
			}
			throw new ArgumentException("Weight cannot be non-positive");
		}

		private int FixWeight(int weight)
		{
			return (BadWeightErrorHandling == WeightErrorHandlingType.ThrowExceptionOnAdd) ? FixWeightExceptionOnAdd(weight) : FixWeightSetToOne(weight);
		}
	}
	public readonly struct WeightedListItem<T>
	{
		internal readonly T _item;

		internal readonly int _weight;

		public WeightedListItem(T item, int weight)
		{
			_item = item;
			_weight = weight;
		}
	}
	public enum WeightErrorHandlingType
	{
		SetWeightToOne,
		ThrowExceptionOnAdd
	}
}
namespace MysteryDice
{
	internal class ConfigManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static GenericButtonHandler <>9__1_0;

			internal void <setupLethalConfig>b__1_0()
			{
				Misc.ToggleAllScanPlayerNodes();
			}
		}

		public static void addConfig(ConfigEntry<bool> config)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(config, true);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
		}

		public static void setupLethalConfig()
		{
			//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_0016: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0028: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//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_003e: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0050: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0078: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//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_008e: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00a0: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00b6: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00c8: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//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_00df: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_00f1: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//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_0108: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_011a: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//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_012d: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_013c: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//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_014f: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			//IL_015e: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//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_0171: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0180: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//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_0193: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_01a2: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//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_01b5: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01c4: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01cb: 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_01d7: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01e6: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//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_01f9: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			//IL_0208: Expected O, but got Unknown
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Expected O, but got Unknown
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Expected O, but got Unknown
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Expected O, but got Unknown
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Expected O, but got Unknown
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Expected O, but got Unknown
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Expected O, but got Unknown
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Expected O, but got Unknown
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Expected O, but got Unknown
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Expected O, but got Unknown
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Expected O, but got Unknown
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Expected O, but got Unknown
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Expected O, but got Unknown
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Expected O, but got Unknown
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Expected O, but got Unknown
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Expected O, but got Unknown
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Expected O, but got Unknown
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Expected O, but got Unknown
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Expected O, but got Unknown
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Expected O, but got Unknown
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Expected O, but got Unknown
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Expected O, but got Unknown
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Expected O, but got Unknown
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Expected O, but got Unknown
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Expected O, but got Unknown
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Expected O, but got Unknown
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Expected O, but got Unknown
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Expected O, but got Unknown
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Expected O, but got Unknown
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Expected O, but got Unknown
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Expected O, but got Unknown
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Expected O, but got Unknown
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Expected O, but got Unknown
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Expected O, but got Unknown
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Expected O, but got Unknown
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Expected O, but got Unknown
			//IL_04c9: Expected O, but got Unknown
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Expected O, but got Unknown
			//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_04dd: Expected O, but got Unknown
			//IL_04de: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Expected O, but got Unknown
			//IL_04ef: Expected O, but got Unknown
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Expected O, but got Unknown
			//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_0503: Expected O, but got Unknown
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Expected O, but got Unknown
			//IL_0515: Expected O, but got Unknown
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Expected O, but got Unknown
			//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)
			//IL_023d: Expected O, but got Unknown
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_072c: Expected O, but got Unknown
			//IL_0751: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Expected O, but got Unknown
			ConfigEntry<float> minHyperShake = MysteryDice.minHyperShake;
			FloatSliderOptions val = new FloatSliderOptions();
			((BaseRangeOptions<float>)val).Min = 0f;
			((BaseRangeOptions<float>)val).Max = 100f;
			FloatSliderConfigItem val2 = new FloatSliderConfigItem(minHyperShake, val);
			ConfigEntry<float> maxHyperShake = MysteryDice.maxHyperShake;
			FloatSliderOptions val3 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val3).Min = 0f;
			((BaseRangeOptions<float>)val3).Max = 100f;
			FloatSliderConfigItem val4 = new FloatSliderConfigItem(maxHyperShake, val3);
			ConfigEntry<float> minNeckSpin = MysteryDice.minNeckSpin;
			FloatSliderOptions val5 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val5).Min = 0f;
			((BaseRangeOptions<float>)val5).Max = 100f;
			FloatSliderConfigItem val6 = new FloatSliderConfigItem(minNeckSpin, val5);
			ConfigEntry<float> rotationSpeedModifier = MysteryDice.rotationSpeedModifier;
			FloatSliderOptions val7 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val7).Min = 0f;
			((BaseRangeOptions<float>)val7).Max = 100f;
			FloatSliderConfigItem val8 = new FloatSliderConfigItem(rotationSpeedModifier, val7);
			ConfigEntry<float> maxNeckSpin = MysteryDice.maxNeckSpin;
			FloatSliderOptions val9 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val9).Min = 0f;
			((BaseRangeOptions<float>)val9).Max = 100f;
			FloatSliderConfigItem val10 = new FloatSliderConfigItem(maxNeckSpin, val9);
			ConfigEntry<float> eggExplodeTime = MysteryDice.eggExplodeTime;
			FloatSliderOptions val11 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val11).Min = 0f;
			((BaseRangeOptions<float>)val11).Max = 5f;
			FloatSliderConfigItem val12 = new FloatSliderConfigItem(eggExplodeTime, val11);
			ConfigEntry<float> soundVolume = MysteryDice.SoundVolume;
			FloatSliderOptions val13 = new FloatSliderOptions();
			((BaseRangeOptions<float>)val13).Min = 0f;
			((BaseRangeOptions<float>)val13).Max = 1f;
			FloatSliderConfigItem val14 = new FloatSliderConfigItem(soundVolume, val13);
			ConfigEntry<int> minNeckBreakTimer = MysteryDice.minNeckBreakTimer;
			IntSliderOptions val15 = new IntSliderOptions();
			((BaseRangeOptions<int>)val15).Min = 0;
			((BaseRangeOptions<int>)val15).Max = 100;
			IntSliderConfigItem val16 = new IntSliderConfigItem(minNeckBreakTimer, val15);
			ConfigEntry<int> maxNeckBreakTimer = MysteryDice.maxNeckBreakTimer;
			IntSliderOptions val17 = new IntSliderOptions();
			((BaseRangeOptions<int>)val17).Min = 0;
			((BaseRangeOptions<int>)val17).Max = 100;
			IntSliderConfigItem val18 = new IntSliderConfigItem(maxNeckBreakTimer, val17);
			ConfigEntry<int> debugButtonAlpha = MysteryDice.DebugButtonAlpha;
			IntSliderOptions val19 = new IntSliderOptions();
			((BaseRangeOptions<int>)val19).Min = 0;
			((BaseRangeOptions<int>)val19).Max = 100;
			IntSliderConfigItem val20 = new IntSliderConfigItem(debugButtonAlpha, val19);
			ConfigEntry<int> debugMenuAccentAlpha = MysteryDice.DebugMenuAccentAlpha;
			IntSliderOptions val21 = new IntSliderOptions();
			((BaseRangeOptions<int>)val21).Min = 0;
			((BaseRangeOptions<int>)val21).Max = 100;
			IntSliderConfigItem val22 = new IntSliderConfigItem(debugMenuAccentAlpha, val21);
			ConfigEntry<int> debugMenuBackgroundAlpha = MysteryDice.DebugMenuBackgroundAlpha;
			IntSliderOptions val23 = new IntSliderOptions();
			((BaseRangeOptions<int>)val23).Min = 0;
			((BaseRangeOptions<int>)val23).Max = 100;
			IntSliderConfigItem val24 = new IntSliderConfigItem(debugMenuBackgroundAlpha, val23);
			ConfigEntry<int> debugMenuTextAlpha = MysteryDice.DebugMenuTextAlpha;
			IntSliderOptions val25 = new IntSliderOptions();
			((BaseRangeOptions<int>)val25).Min = 0;
			((BaseRangeOptions<int>)val25).Max = 100;
			IntSliderConfigItem val26 = new IntSliderConfigItem(debugMenuTextAlpha, val25);
			ConfigEntry<int> debugMenuFavoriteTextAlpha = MysteryDice.DebugMenuFavoriteTextAlpha;
			IntSliderOptions val27 = new IntSliderOptions();
			((BaseRangeOptions<int>)val27).Min = 0;
			((BaseRangeOptions<int>)val27).Max = 100;
			IntSliderConfigItem val28 = new IntSliderConfigItem(debugMenuFavoriteTextAlpha, val27);
			object obj = <>c.<>9__1_0;
			if (obj == null)
			{
				GenericButtonHandler val29 = delegate
				{
					Misc.ToggleAllScanPlayerNodes();
				};
				<>c.<>9__1_0 = val29;
				obj = (object)val29;
			}
			GenericButtonConfigItem val30 = new GenericButtonConfigItem("Clientside", "Toggle Controllers", "Hides/Shows the custom scannodes attached to people", "Toggle Scannodes", (GenericButtonHandler)obj);
			IntInputFieldConfigItem val31 = new IntInputFieldConfigItem(MysteryDice.EmergencyDiePrice, true);
			IntInputFieldConfigItem val32 = new IntInputFieldConfigItem(MysteryDice.brutalStartingScale, false);
			IntInputFieldConfigItem val33 = new IntInputFieldConfigItem(MysteryDice.brutalMaxScale, false);
			IntInputFieldConfigItem val34 = new IntInputFieldConfigItem(MysteryDice.brutalScaleType, false);
			BoolCheckBoxConfigItem val35 = new BoolCheckBoxConfigItem(MysteryDice.DieEmergencyAsScrap, true);
			IntInputFieldConfigItem val36 = new IntInputFieldConfigItem(BlameGlitch.minNum, false);
			IntInputFieldConfigItem val37 = new IntInputFieldConfigItem(BlameGlitch.maxNum, false);
			IntInputFieldConfigItem val38 = new IntInputFieldConfigItem(MysteryDice.hyperShakeTimer, false);
			IntInputFieldConfigItem val39 = new IntInputFieldConfigItem(MysteryDice.neckRotations, false);
			TextInputFieldConfigItem val40 = new TextInputFieldConfigItem(MysteryDice.DisplayResults);
			TextInputFieldConfigItem val41 = new TextInputFieldConfigItem(MysteryDice.debugChat);
			BoolCheckBoxConfigItem val42 = new BoolCheckBoxConfigItem(BlameGlitch.isInside, false);
			BoolCheckBoxConfigItem val43 = new BoolCheckBoxConfigItem(BlameGlitch.bothInsideOutside, false);
			BoolCheckBoxConfigItem val44 = new BoolCheckBoxConfigItem(MysteryDice.pussyMode, false);
			BoolCheckBoxConfigItem val45 = new BoolCheckBoxConfigItem(MysteryDice.DebugLogging, false);
			BoolCheckBoxConfigItem val46 = new BoolCheckBoxConfigItem(MysteryDice.randomSpinTime, true);
			BoolCheckBoxConfigItem val47 = new BoolCheckBoxConfigItem(MysteryDice.chronosUpdatedTimeOfDay, false);
			BoolCheckBoxConfigItem val48 = new BoolCheckBoxConfigItem(MysteryDice.useDiceOutside, false);
			BoolCheckBoxConfigItem val49 = new BoolCheckBoxConfigItem(MysteryDice.debugDice, false);
			BoolCheckBoxConfigItem val50 = new BoolCheckBoxConfigItem(MysteryDice.TwitchEnabled, true);
			BoolCheckBoxConfigItem val51 = new BoolCheckBoxConfigItem(MysteryDice.CopyrightFree, false);
			BoolCheckBoxConfigItem val52 = new BoolCheckBoxConfigItem(MysteryDice.allowChatCommands, true);
			BoolCheckBoxConfigItem val53 = new BoolCheckBoxConfigItem(MysteryDice.useNeckBreakTimer, false);
			BoolCheckBoxConfigItem val54 = new BoolCheckBoxConfigItem(MysteryDice.debugMenuShowsAll, false);
			BoolCheckBoxConfigItem val55 = new BoolCheckBoxConfigItem(MysteryDice.debugButton, true);
			BoolCheckBoxConfigItem val56 = new BoolCheckBoxConfigItem(MysteryDice.BetterDebugMenu, false);
			BoolCheckBoxConfigItem val57 = new BoolCheckBoxConfigItem(MysteryDice.Bald, false);
			BoolCheckBoxConfigItem val58 = new BoolCheckBoxConfigItem(MysteryDice.LockDebugUI, false);
			BoolCheckBoxConfigItem val59 = new BoolCheckBoxConfigItem(BlameGlitch.GlitchedMeteorShower, false);
			BoolCheckBoxConfigItem val60 = new BoolCheckBoxConfigItem(AlarmCurse.fireAlarm, false);
			BoolCheckBoxConfigItem val61 = new BoolCheckBoxConfigItem(AlarmCurse.HorribleVersion, false);
			BoolCheckBoxConfigItem val62 = new BoolCheckBoxConfigItem(MysteryDice.doDiceExplosion, false);
			BoolCheckBoxConfigItem val63 = new BoolCheckBoxConfigItem(MysteryDice.LoversOnStart, false);
			BoolCheckBoxConfigItem val64 = new BoolCheckBoxConfigItem(MysteryDice.insideJoke, false);
			BoolCheckBoxConfigItem val65 = new BoolCheckBoxConfigItem(MysteryDice.DebugMenuClosesAfter, false);
			BoolCheckBoxConfigItem val66 = new BoolCheckBoxConfigItem(MysteryDice.BrutalMode, false);
			BoolCheckBoxConfigItem val67 = new BoolCheckBoxConfigItem(MysteryDice.BrutalChat, false);
			BoolCheckBoxConfigItem val68 = new BoolCheckBoxConfigItem(MysteryDice.debugSpawnOnPlayer, false);
			BoolCheckBoxConfigItem val69 = new BoolCheckBoxConfigItem(MysteryDice.SuperBrutalMode, false);
			BoolCheckBoxConfigItem val70 = new BoolCheckBoxConfigItem(MysteryDice.yippeeUse, false);
			HexColorInputFieldConfigItem val71 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuTextColor, false);
			HexColorInputFieldConfigItem val72 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuFavoriteTextColor, false);
			HexColorInputFieldConfigItem val73 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuBackgroundColor, false);
			HexColorInputFieldConfigItem val74 = new HexColorInputFieldConfigItem(MysteryDice.DebugMenuAccentColor, false);
			HexColorInputFieldConfigItem val75 = new HexColorInputFieldConfigItem(MysteryDice.DebugButtonColor, false);
			BoolCheckBoxConfigItem val76 = new BoolCheckBoxConfigItem(MysteryDice.ConfigGalAutomatic, false);
			BoolCheckBoxConfigItem val77 = new BoolCheckBoxConfigItem(MysteryDice.ConfigOnlyOwnerDisablesGal, false);
			ConfigEntry<int> imFeelingLuckyCooldown = MysteryDice.ImFeelingLuckyCooldown;
			IntInputFieldOptions val78 = new IntInputFieldOptions();
			((BaseRangeOptions<int>)val78).Min = 10;
			((BaseRangeOptions<int>)val78).Max = 600;
			IntInputFieldConfigItem val79 = new IntInputFieldConfigItem(imFeelingLuckyCooldown, val78);
			ConfigEntry<int> onTheHouseCooldown = MysteryDice.OnTheHouseCooldown;
			IntInputFieldOptions val80 = new IntInputFieldOptions();
			((BaseRangeOptions<int>)val80).Min = 10;
			((BaseRangeOptions<int>)val80).Max = 600;
			IntInputFieldConfigItem val81 = new IntInputFieldConfigItem(onTheHouseCooldown, val80);
			ConfigEntry<int> devilDealCooldown = MysteryDice.DevilDealCooldown;
			IntInputFieldOptions val82 = new IntInputFieldOptions();
			((BaseRangeOptions<int>)val82).Min = 10;
			((BaseRangeOptions<int>)val82).Max = 600;
			IntInputFieldConfigItem val83 = new IntInputFieldConfigItem(devilDealCooldown, val82);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val49);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val48);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val66);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val67);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val69);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val32);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val33);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val34);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val71);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val26);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val72);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val28);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val73);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val24);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val74);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val64);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val22);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val75);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val20);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val56);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val47);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val46);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val44);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val53);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val14);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val40);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val51);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val38);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val12);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val65);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val70);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val6);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val10);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val8);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val16);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val18);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val76);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val77);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val79);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val81);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val83);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val39);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val42);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val43);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val36);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val37);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val54);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val55);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val68);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val41);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val50);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val45);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val57);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val31);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val63);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val35);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val62);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val59);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val60);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val58);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val61);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val30);
			if (MysteryDice.SurfacedPresent)
			{
				BoolCheckBoxConfigItem val84 = new BoolCheckBoxConfigItem(Flinger.beybladeMode, false);
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val84);
			}
			foreach (ConfigEntry<bool> effectConfig in DieBehaviour.effectConfigs)
			{
				BoolCheckBoxConfigItem val85 = new BoolCheckBoxConfigItem(effectConfig, true);
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val85);
			}
		}
	}
	internal static class CullFactorySoftCompat
	{
		private static readonly bool CullFactoryAvailable;

		private static readonly MethodInfo RefreshGrabbableMethod;

		private static readonly MethodInfo RefreshLightMethod;

		static CullFactorySoftCompat()
		{
			if (Chainloader.PluginInfos.TryGetValue("com.fumiko.CullFactory", out var value) && value.Metadata.Version >= new Version(1, 5, 0))
			{
				Type type = Type.GetType("CullFactory.Behaviours.API.DynamicObjectsAPI, CullFactory");
				if (type != null)
				{
					RefreshGrabbableMethod = type.GetMethod("RefreshGrabbableObjectPosition", BindingFlags.Static | BindingFlags.Public);
					RefreshLightMethod = type.GetMethod("RefreshLightPosition", BindingFlags.Static | BindingFlags.Public);
					CullFactoryAvailable = RefreshGrabbableMethod != null && RefreshLightMethod != null;
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void RefreshGrabbableObjectPosition(GrabbableObject item)
		{
			item.EnableItemMeshes(true);
			if (CullFactoryAvailable)
			{
				RefreshGrabbableMethod?.Invoke(null, new object[1] { item });
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void RefreshLightPosition(Light light)
		{
			if (CullFactoryAvailable)
			{
				RefreshLightMethod?.Invoke(null, new object[1] { light });
			}
		}
	}
	public class IngameKeybinds : LcInputActions
	{
		[InputAction("<Keyboard>/numpadMinus", Name = "DebugMenu")]
		public InputAction DebugMenu { get; set; } = null;

		[InputAction("<Keyboard>/space", Name = "FlyButton")]
		public InputAction FlyButton { get; set; } = null;

		[InputAction("<Keyboard>/ctrl", Name = "FlyDownButton")]
		public InputAction FlyDownButton { get; set; } = null;
	}
	public class Misc
	{
		public static Item GetItemByName(string itemName, bool matchCase = true)
		{
			StringComparison comparisonType = ((!matchCase) ? StringComparison.OrdinalIgnoreCase : StringComparison.CurrentCulture);
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				if (items.itemName.Equals(itemName, comparisonType))
				{
					return items;
				}
			}
			foreach (SpawnableItemWithRarity item in RoundManager.Instance.currentLevel.spawnableScrap)
			{
				if (item.spawnableItem.itemName.Equals(itemName, comparisonType))
				{
					return item.spawnableItem;
				}
			}
			return null;
		}

		public static void SpawnEnemy(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false)
		{
			//IL_00ea: 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_005e: 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)
			if (!((NetworkBehaviour)Networker.Instance).IsHost)
			{
				return;
			}
			RoundManager instance = RoundManager.Instance;
			if (isInside)
			{
				if (isInvisible)
				{
					for (int i = 0; i < amount; i++)
					{
						EnemyVent val = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
						GameObject val2 = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, val.floorNode.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
						SetObjectInvisible(val2);
						val2.GetComponentInChildren<NetworkObject>().Spawn(true);
						instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
					}
				}
				else
				{
					for (int j = 0; j < amount; j++)
					{
						EnemyVent val3 = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
						instance.SpawnEnemyOnServer(val3.floorNode.position, val3.floorNode.eulerAngles.y, instance.currentLevel.Enemies.IndexOf(enemy));
					}
				}
			}
			else
			{
				for (int k = 0; k < amount; k++)
				{
					SpawnOutsideEnemy(enemy);
				}
			}
		}

		public static void SpawnEnemy(EnemyType enemy, int amount, bool isInside, bool isInvisible = false)
		{
			//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_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_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_0087: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)Networker.Instance).IsHost)
			{
				return;
			}
			RoundManager instance = RoundManager.Instance;
			Vector3 position = instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position;
			EnemyVent val = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
			if (isInside)
			{
				position = val.floorNode.position;
			}
			for (int i = 0; i < amount; i++)
			{
				GameObject val2 = Object.Instantiate<GameObject>(enemy.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				if (isInvisible)
				{
					SetObjectInvisible(val2);
				}
				val2.GetComponentInChildren<NetworkObject>().Spawn(true);
				instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
			}
		}

		public static bool canDiceYet()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return false;
			}
			if (StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded)
			{
				return false;
			}
			return true;
		}

		public static int playerCount()
		{
			int num = 0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB player in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(player))
				{
					num++;
				}
			}
			return num;
		}

		public static void SetObjectInvisible(GameObject obj)
		{
			//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_00ca: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = obj.GetComponentsInChildren<Renderer>();
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					val2.shader = Shader.Find("Standard");
					val2.SetFloat("_Mode", 3f);
					val2.SetInt("_SrcBlend", 5);
					val2.SetInt("_DstBlend", 10);
					val2.SetInt("_ZWrite", 0);
					val2.DisableKeyword("_ALPHATEST_ON");
					val2.EnableKeyword("_ALPHABLEND_ON");
					val2.DisableKeyword("_ALPHAPREMULTIPLY_ON");
					val2.renderQueue = 3000;
					Color color = val2.color;
					color.a = 0.1f;
					val2.color = color;
				}
			}
		}

		public static PlayerControllerB getPlayerBySteamID(ulong steamID)
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerReal(val))
				{
					list.Add(val);
				}
			}
			return list.Where((PlayerControllerB x) => x.playerSteamId == steamID).FirstOrDefault();
		}

		public static void SpawnOutsideEnemy(SpawnableEnemyWithRarity enemy)
		{
			//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_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_007c: 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_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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			GameObject[] source = GameObject.FindGameObjectsWithTag("OutsideAINode");
			source = source.OrderBy((GameObject x) => Vector3.Distance(x.transform.position, Vector3.zero)).ToArray();
			Vector3 position = instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position;
			position = instance.GetRandomNavMeshPositionInBoxPredictable(position, 30f, default(NavMeshHit), random, -1, 1f) + Vector3.up;
			GameObject val = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
		}

		public static List<GameObject> SpawnEnemy(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false, bool returnObject = false)
		{
			//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_007b: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = new List<GameObject>();
			if (!((NetworkBehaviour)Networker.Instance).IsHost)
			{
				return list;
			}
			RoundManager instance = RoundManager.Instance;
			if (isInside)
			{
				for (int i = 0; i < amount; i++)
				{
					EnemyVent val = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
					GameObject val2 = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, val.floorNode.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
					if (isInvisible)
					{
						SetObjectInvisible(val2);
					}
					val2.GetComponentInChildren<NetworkObject>().Spawn(true);
					instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
					list.Add(val2);
				}
			}
			else
			{
				for (int j = 0; j < amount; j++)
				{
					list.Add(SpawnOutsideEnemy(enemy, returnObject: true));
				}
			}
			return list;
		}

		public static GameObject SpawnOutsideEnemy(SpawnableEnemyWithRarity enemy, bool returnObject)
		{
			//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_0075: 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_0084: 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_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_00a9: 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)
			List<GameObject> list = new List<GameObject>();
			RoundManager instance = RoundManager.Instance;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			GameObject[] source = GameObject.FindGameObjectsWithTag("OutsideAINode");
			source = source.OrderBy((GameObject x) => Vector3.Distance(x.transform.position, Vector3.zero)).ToArray();
			Vector3 position = instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position;
			position = instance.GetRandomNavMeshPositionInBoxPredictable(position, 30f, default(NavMeshHit), random, -1, 1f) + Vector3.up;
			GameObject val = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			return val;
		}

		public static void SpawnEnemyForced(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false)
		{
			if (!RoundManager.Instance.currentLevel.Enemies.Contains(enemy))
			{
				RoundManager.Instance.currentLevel.Enemies.Add(enemy);
				SpawnEnemy(enemy.enemyType, amount, isInside, isInvisible);
				RoundManager.Instance.currentLevel.Enemies.Remove(enemy);
			}
			else
			{
				SpawnEnemy(enemy.enemyType, amount, isInside, isInvisible);
			}
		}

		public static List<GameObject> SpawnEnemyForced2(SpawnableEnemyWithRarity enemy, int amount, bool isInside, bool isInvisible = false, bool returnObject = false)
		{
			List<GameObject> list = new List<GameObject>();
			if (!RoundManager.Instance.currentLevel.Enemies.Contains(enemy))
			{
				RoundManager.Instance.currentLevel.Enemies.Add(enemy);
				list = SpawnEnemy(enemy, amount, isInside, isInvisible, returnObject: true);
				RoundManager.Instance.currentLevel.Enemies.Remove(enemy);
			}
			else
			{
				list = SpawnEnemy(enemy, amount, isInside, isInvisible, returnObject: true);
			}
			return list;
		}

		public static float Map(float x, float inMin, float inMax, float outMin, float outMax)
		{
			return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
		}

		public static PlayerControllerB GetPlayerByUserID(int userID)
		{
			return StartOfRound.Instance.allPlayerScripts[userID];
		}

		public static NetworkObjectReference SpawnEnemyOnServer(Vector3 spawnPosition, float yRot, SpawnableEnemyWithRarity enemy)
		{
			//IL_0003: 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_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_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_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_0076: Unknown result type (might be due to invalid IL or missing references)
			NetworkObjectReference result = default(NetworkObjectReference);
			if (!((NetworkBehaviour)Networker.Instance).IsServer)
			{
				return result;
			}
			GameObject val = Object.Instantiate<GameObject>(enemy.enemyType.enemyPrefab, spawnPosition, Quaternion.Euler(new Vector3(0f, yRot, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			return NetworkObjectReference.op_Implicit(val.GetComponentInChildren<NetworkObject>());
		}

		public static void ToggleAllScanPlayerNodes(bool fromConfig = false)
		{
			if (Networker.Instance.playerScanNodes == null)
			{
				return;
			}
			GameObject[] array = Networker.Instance.playerScanNodes.ToArray();
			PlayerTracker playerTracker = default(PlayerTracker);
			foreach (GameObject playerScanNode in Networker.Instance.playerScanNodes)
			{
				if (!Object.op_Implicit((Object)(object)playerScanNode) || !playerScanNode.TryGetComponent<PlayerTracker>(ref playerTracker))
				{
					continue;
				}
				if (fromConfig)
				{
					if (((NetworkBehaviour)playerTracker.trackedPlayer).IsLocalPlayer)
					{
						playerScanNode.SetActive(MysteryDice.showOwnScanNode.Value);
					}
				}
				else if (((NetworkBehaviour)playerTracker.trackedPlayer).IsLocalPlayer && !MysteryDice.showOwnScanNode.Value)
				{
					if (playerScanNode.activeSelf)
					{
						playerScanNode.SetActive(false);
					}
				}
				else
				{
					playerScanNode.SetActive(!playerScanNode.activeSelf);
				}
			}
		}

		public static void ChatWrite(string chatMessage)
		{
			HUDManager.Instance.lastChatMessage = chatMessage;
			HUDManager.Instance.PingHUDElement(HUDManager.Instance.Chat, 4f, 1f, 0.2f);
			if (HUDManager.Instance.ChatMessageHistory.Count >= 4)
			{
				((TMP_Text)HUDManager.Instance.chatText).text.Remove(0, HUDManager.Instance.ChatMessageHistory[0].Length);
				HUDManager.Instance.ChatMessageHistory.Remove(HUDManager.Instance.ChatMessageHistory[0]);
			}
			string item = "<color=#00ffff>" + chatMessage + "</color>";
			HUDManager.Instance.ChatMessageHistory.Add(item);
			((TMP_Text)HUDManager.Instance.chatText).text = "";
			for (int i = 0; i < HUDManager.Instance.ChatMessageHistory.Count; i++)
			{
				TextMeshProUGUI chatText = HUDManager.Instance.chatText;
				((TMP_Text)chatText).text = ((TMP_Text)chatText).text + "\n" + HUDManager.Instance.ChatMessageHistory[i];
			}
		}

		public static trap[] getAllTraps()
		{
			List<trap> list = new List<trap>();
			List<SpawnableMapObject> list2 = (from x in StartOfRound.Instance.levels.SelectMany((SelectableLevel level) => level.spawnableMapObjects)
				group x by ((Object)x.prefabToSpawn).name into g
				select g.First()).ToList();
			foreach (SpawnableMapObject item2 in list2)
			{
				list.Add(new trap(((Object)item2.prefabToSpawn).name, item2.prefabToSpawn));
			}
			if (MysteryDice.CodeRebirthPresent)
			{
				HashSet<string> hashSet = new HashSet<string>(list.Select((trap x) => NormalizeName(x.name)));
				foreach (trap spawnPrefab in CodeRebirthCheckConfigs.getSpawnPrefabs())
				{
					string item = NormalizeName(spawnPrefab.name);
					if (!hashSet.Contains(item))
					{
						list.Add(spawnPrefab);
						hashSet.Add(item);
					}
				}
			}
			return list.ToArray();
			static string NormalizeName(string input)
			{
				return new string(input.Where((char c) => !char.IsWhiteSpace(c)).ToArray()).ToLowerInvariant();
			}
		}

		public static void SafeTipMessage(string title, string body)
		{
			try
			{
				HUDManager.Instance.DisplayTip(title, body, false, false, "LC_Tip1");
			}
			catch
			{
				MysteryDice.CustomLogger.LogWarning((object)"There's a problem with the DisplayTip method. This might have happened due to a new game verison, or some other mod.");
				try
				{
					ChatWrite(title + ": " + body);
				}
				catch
				{
					MysteryDice.CustomLogger.LogWarning((object)"There's a problem with writing to the chat. This might have happened due to a new game verison, or some other mod.");
				}
			}
		}

		public static int TotalAlive()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(val))
				{
					list.Add(val);
				}
			}
			return list.Count;
		}

		public static bool isPlayerLocal(int userID)
		{
			return (Object)(object)StartOfRound.Instance.allPlayerScripts[userID] == (Object)(object)StartOfRound.Instance.localPlayerController;
		}

		public static PlayerControllerB GetRandomAlivePlayer(int notThisPlayer = -1)
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(val))
				{
					list.Add(val);
				}
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			PlayerControllerB val2 = list[Random.Range(0, list.Count)];
			if (notThisPlayer != -1)
			{
				for (int j = 0; Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val2) == notThisPlayer || j > 10; j++)
				{
					val2 = list[Random.Range(0, list.Count)];
				}
			}
			return val2;
		}

		public static int GetRandomPlayerID()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerAliveAndControlled(val))
				{
					list.Add(val);
				}
			}
			return Array.IndexOf(StartOfRound.Instance.allPlayerScripts, list[Random.Range(0, list.Count)]);
		}

		public static PlayerControllerB GetRandomPlayer()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsPlayerReal(val))
				{
					list.Add(val);
				}
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			return list[Random.Range(0, list.Count)];
		}

		public static bool IsPlayerAliveAndControlled(PlayerControllerB player)
		{
			return !player.isPlayerDead && player.isPlayerControlled;
		}

		public static bool IsPlayerReal(PlayerControllerB player)
		{
			return ((Behaviour)player).isActiveAndEnabled || player.isPlayerDead;
		}

		public static SpawnableEnemyWithRarity getEnemyByName(string name)
		{
			HashSet<SpawnableEnemyWithRarity> hashSet = new HashSet<SpawnableEnemyWithRarity>();
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel val in levels)
			{
				hashSet.UnionWith(val.Enemies);
				hashSet.UnionWith(val.OutsideEnemies);
				hashSet.UnionWith(val.DaytimeEnemies);
			}
			List<SpawnableEnemyWithRarity> source = (from x in hashSet
				group x by x.enemyType.enemyName into g
				select g.First() into x
				orderby x.enemyType.enemyName
				select x).ToList();
			return ((IEnumerable<SpawnableEnemyWithRarity>)source).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName == name));
		}

		public static void AdjustWeight(int userID, float factor)
		{
			PlayerControllerB val = null;
			val = StartOfRound.Instance.allPlayerScripts[userID];
			if ((Object)(object)val == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"Player not found.");
				return;
			}
			float num = 0f;
			float num2 = 0f;
			GrabbableObject[] itemSlots = val.ItemSlots;
			foreach (GrabbableObject val2 in itemSlots)
			{
				if (!((Object)(object)val2 == (Object)null) && val2.itemProperties.weight != 0f)
				{
					float num3 = Mathf.Clamp(val2.itemProperties.weight - 1f, 0f, 100f);
					float num4 = Mathf.RoundToInt(num3 * 105f);
					num4 *= factor;
					num2 += num4;
					float num5 = Mathf.Clamp(num4 / 105f + 1f, 1f, 10f);
					val2.itemProperties.weight = num5;
					num += num5;
				}
			}
			float num6 = Mathf.Clamp(num2 / 105f + 1f, 1f, 10f);
			if (num6 != 0f)
			{
				val.carryWeight = num6;
			}
		}
	}
	public class trap
	{
		public string name;

		public GameObject prefab;

		public trap(string _name, GameObject _prefab)
		{
			name = _name;
			prefab = _prefab;
		}
	}
	[BepInPlugin("Theronguard.EmergencyDice", "Emergency Dice Updated", "1.14.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MysteryDice : BaseUnityPlugin
	{
		public enum chatDebug
		{
			Host,
			Everyone,
			None
		}

		public static HashSet<ulong> admins = new HashSet<ulong> { 76561198077184650uL, 76561199094139351uL, 76561198984467725uL, 76561198399127090uL, 76561198086086035uL, 76561198216220844uL };

		public static HashSet<ulong> revokedAdmins = new HashSet<ulong>();

		public static readonly ulong slayerSteamID = 76561198077184650uL;

		internal static bool isAdmin = false;

		internal static bool triedRequestingAdmin = false;

		private const string modGUID = "Theronguard.EmergencyDice";

		private const string modName = "Emergency Dice Updated";

		private const string modVersion = "1.14.2";

		private readonly Harmony harmony = new Harmony("Theronguard.EmergencyDice");

		public static ManualLogSource CustomLogger;

		public static AssetBundle LoadedAssets;

		public static AssetBundle LoadedAssets2;

		internal static IngameKeybinds Keybinds = null;

		public static UnlockableItemDef diceGalUnlockable;

		public static GameObject NetworkerPrefab;

		public static GameObject JumpscareCanvasPrefab;

		public static GameObject SpiderCanvasPrefab;

		public static GameObject SpiderMoverPrefab;

		public static GameObject JumpscareOBJ;

		public static GameObject PathfinderPrefab;

		public static GameObject DebugMenuPrefab;

		public static GameObject NewSelectMenuPrefab;

		public static GameObject DebugMenuButtonPrefab;

		public static GameObject DebugSubButtonPrefab;

		public static GameObject DiceGal;

		public static GameObject AgentObjectPrefab;

		public static GameObject PlayerNodeController;

		public static Material jobApplication;

		public static Material angyGlitch;

		public static Material angyFish;

		public static Jumpscare JumpscareScript;

		public static Dictionary<string, AudioClip> sounds = new Dictionary<string, AudioClip>();

		public static Sprite WarningBracken;

		public static Sprite WarningJester;

		public static Sprite WarningDeath;

		public static Sprite WarningLuck;

		public static Item DieEmergency;

		public static Item DieGambler;

		public static Item DieChronos;

		public static Item DieSacrificer;

		public static Item DieSaint;

		public static Item DieRusty;

		public static Item DieSurfaced;

		public static Item DieCodeRebirth;

		public static Item DieSteve;

		public static Item PathfinderSpawner;

		public static ConfigFile BepInExConfig = null;

		public static ConfigFile ClientSideConfigs = null;

		public static bool lethalThingsPresent = false;

		public static bool LethalMonPresent = false;

		public static bool LCOfficePresent = false;

		public static bool CodeRebirthPresent = false;

		public static bool SurfacedPresent = false;

		public static bool LCTarotCardPresent = false;

		public static bool TakeyPlushPresent = false;

		public static bool TooManyEmotesPresent = false;

		public static bool DiversityPresent = false;

		public static bool NightOfTheLivingMimicPresent = false;

		public static bool NavMeshInCompanyPresent = false;

		public static bool BombCollarPresent = false;

		public static bool MoreCompanyPresent = false;

		public static bool LethalConfigPresent = false;

		public static bool terminalLockout = false;

		public static CustomConfigs customCfg;

		public static bool isHalloween = false;

		private static string directoryPath;

		public static ConfigEntry<bool> aprilFoolsConfig;

		public static ConfigEntry<bool> pussyMode;

		public static ConfigEntry<float> minHyperShake;

		public static ConfigEntry<float> maxHyperShake;

		public static ConfigEntry<bool> randomSpinTime;

		public static ConfigEntry<bool> ConfigOnlyOwnerDisablesGal;

		public static ConfigEntry<bool> ConfigGalAutomatic;

		public static ConfigEntry<bool> chronosUpdatedTimeOfDay;

		public static ConfigEntry<bool> useDiceOutside;

		public static ConfigEntry<bool> debugDice;

		public static ConfigEntry<bool> allowChatCommands;

		public static ConfigEntry<float> eggExplodeTime;

		public static ConfigEntry<float> minNeckSpin;

		public static ConfigEntry<float> maxNeckSpin;

		public static ConfigEntry<int> neckRotations;

		public static ConfigEntry<float> rotationSpeedModifier;

		public static ConfigEntry<bool> useNeckBreakTimer;

		public static ConfigEntry<bool> debugMenuShowsAll;

		public static ConfigEntry<bool> yippeeUse;

		public static ConfigEntry<bool> insideJoke;

		public static ConfigEntry<int> minNeckBreakTimer;

		public static ConfigEntry<int> maxNeckBreakTimer;

		public static ConfigEntry<int> hyperShakeTimer;

		public static ConfigEntry<int> EmergencyDiePrice;

		public static ConfigEntry<int> CustomEnemyEventCount;

		public static ConfigEntry<int> CustomItemEventCount;

		public static ConfigEntry<int> CustomTrapEventCount;

		public static ConfigEntry<string> DebugMenuTextColor;

		public static ConfigEntry<int> DebugMenuTextAlpha;

		public static ConfigEntry<string> DebugMenuFavoriteTextColor;

		public static ConfigEntry<int> DebugMenuFavoriteTextAlpha;

		public static ConfigEntry<string> DebugMenuBackgroundColor;

		public static ConfigEntry<int> DebugMenuBackgroundAlpha;

		public static ConfigEntry<string> DebugMenuAccentColor;

		public static ConfigEntry<int> DebugMenuAccentAlpha;

		public static ConfigEntry<string> DebugButtonColor;

		public static ConfigEntry<string> cursedIDs;

		public static ConfigEntry<bool> cursedRandomly;

		public static ConfigEntry<bool> toggleCursed;

		public static ConfigEntry<int> DebugButtonAlpha;

		public static ConfigEntry<bool> BrutalMode;

		public static ConfigEntry<bool> BrutalChat;

		public static ConfigEntry<bool> SuperBrutalMode;

		public static ConfigEntry<int> brutalStartingScale;

		public static ConfigEntry<int> brutalMaxScale;

		public static ConfigEntry<int> ImFeelingLuckyCooldown;

		public static ConfigEntry<int> DevilDealCooldown;

		public static ConfigEntry<int> OnTheHouseCooldown;

		public static ConfigEntry<int> brutalScaleType;

		public static ConfigEntry<bool> showOwnScanNode;

		public static ConfigEntry<bool> Bald;

		public static ConfigEntry<bool> CopyrightFree;

		public static ConfigEntry<float> SoundVolume;

		public static ConfigEntry<bool> debugButton;

		public static ConfigEntry<bool> debugSpawnOnPlayer;

		public static ConfigEntry<bool> superDebugMode;

		public static ConfigEntry<bool> DebugLogging;

		public static ConfigEntry<bool> BetterDebugMenu;

		public static ConfigEntry<bool> LockDebugUI;

		public static ConfigEntry<bool> doDiceExplosion;

		public static ConfigEntry<bool> DieEmergencyAsScrap;

		public static ConfigEntry<bool> DisableGal;

		public static ConfigEntry<bool> CompanyGal;

		public static ConfigEntry<int> GalPrice;

		public static ConfigEntry<bool> LoversOnStart;

		public static ConfigEntry<bool> DebugMenuClosesAfter;

		public static ConfigEntry<bool> TwitchEnabled;

		public static ConfigEntry<string> DisplayResults;

		public static ConfigEntry<string> debugChat;

		public static ConfigEntry<bool> deadAds;

		public static Dictionary<string, LevelTypes> RegLevels = new Dictionary<string, LevelTypes>
		{
			{
				"Experimentation",
				(LevelTypes)4
			},
			{
				"Assurance",
				(LevelTypes)8
			},
			{
				"Vow",
				(LevelTypes)16
			},
			{
				"Offense",
				(LevelTypes)32
			},
			{
				"March",
				(LevelTypes)64
			},
			{
				"Rend",
				(LevelTypes)128
			},
			{
				"Dine",
				(LevelTypes)256
			},
			{
				"Titan",
				(LevelTypes)512
			},
			{
				"Adamance",
				(LevelTypes)2048
			},
			{
				"Artifice",
				(LevelTypes)4096
			},
			{
				"Embrion",
				(LevelTypes)8192
			}
		};

		public static List<Item> RegisteredDice = new List<Item>();

		public static void ModConfig()
		{
			pussyMode = ClientSideConfigs.Bind<bool>("Clientside", "Pussy mode", true, "Changes the jumpscare effect to a less scary one.");
			deadAds = ClientSideConfigs.Bind<bool>("Clientside", "Dead Ads", true, "Do Ads play while dead.");
			DieEmergencyAsScrap = BepInExConfig.Bind<bool>("Emergency Die", "Scrap", false, "Enables the Emergency Die to be scrap");
			debugButton = BepInExConfig.Bind<bool>("Admin", "Debug Button", false, "Enables the debug button(Must be host)");
			superDebugMode = BepInExConfig.Bind<bool>("Admin", "Super Debug", false, "You probably don't want this, it makes clients be able to use the menu");
			debugMenuShowsAll = BepInExConfig.Bind<bool>("Admin", "Debug Menu Shows All Events", false, "Makes the debug menu show all the events even if turned off");
			BetterDebugMenu = BepInExConfig.Bind<bool>("Admin", "Better Debug Menu", false, "Enables the Better Debug Menu");
			LockDebugUI = ClientSideConfigs.Bind<bool>("New Debug", "Lock input", true, "Locks input while the UI is open");
			debugDice = BepInExConfig.Bind<bool>("Admin", "Show effects in the console", false, "Shows what effect has been rolled by the dice in the console. For debug purposes.");
			debugChat = BepInExConfig.Bind<string>("Admin", "Show effects in the chat", chatDebug.None.ToString(), "Shows what effect has been rolled by the dice in the chat. For debug purposes.\nOptions are: Host, Everyone, None");
			DebugMenuTextColor = ClientSideConfigs.Bind<string>("New Debug", "Text Color", "#F581FA", "Sets the text color of the Debug Menu.");
			DebugMenuTextAlpha = ClientSideConfigs.Bind<int>("New Debug", "Text Alpha", 100, "Sets the text alpha of the Debug Menu.");
			debugSpawnOnPlayer = ClientSideConfigs.Bind<bool>("New Debug", "debugSpawnOnPlayer", true, "Spawn Enemy On Player with the Debug Menu.");
			ConfigOnlyOwnerDisablesGal = BepInExConfig.Bind<bool>("Gal", "Only Owner Disables Gal", true, "Makes it to where only the owner can disable the Gal");
			ConfigGalAutomatic = BepInExConfig.Bind<bool>("Gal", "Auto Activate", false, "Makes the Gal automatically activate");
			DisableGal = BepInExConfig.Bind<bool>("Gal", "Disable Completely", false, "Makes the gal not show up in the shop, and adds the gal effects to the dice pool");
			CompanyGal = BepInExConfig.Bind<bool>("Gal", "Disable on Company", true, "Makes the gal not be able to be activated on company moons");
			GalPrice = BepInExConfig.Bind<int>("Gal", "Price", 1777, "Sets the price of the Gal.");
			ImFeelingLuckyCooldown = BepInExConfig.Bind<int>("Gal", "Im Feeling Lucky Cooldown", 120, "How long is the cooldown for I'm Feeling Lucky Gal Effect");
			DevilDealCooldown = BepInExConfig.Bind<int>("Gal", "Devil Deal Cooldown", 90, "How long is the cooldown for Devil Deal Gal Effect");
			OnTheHouseCooldown = BepInExConfig.Bind<int>("Gal", "On The House Cooldown", 300, "How long is the cooldown for On The House Gal Effect");
			DebugMenuFavoriteTextColor = ClientSideConfigs.Bind<string>("New Debug", "Favorite Text Color", "#F53548", "Sets the favorite text color of the Debug Menu.");
			DebugMenuFavoriteTextAlpha = ClientSideConfigs.Bind<int>("New Debug", "Favorite Text Alpha", 100, "Sets the favorite alpha of the Debug Menu.");
			DebugMenuBackgroundColor = ClientSideConfigs.Bind<string>("New Debug", "Background Color", "#270051", "Sets the background color of the Debug Menu.");
			DebugMenuBackgroundAlpha = ClientSideConfigs.Bind<int>("New Debug", "Background Alpha", 46, "Sets the background alpha of the Debug Menu.");
			DebugMenuAccentColor = ClientSideConfigs.Bind<string>("New Debug", "Accent Color", "#A34EFF", "Sets the accent color of the Debug Menu.");
			DebugMenuAccentAlpha = ClientSideConfigs.Bind<int>("New Debug", "Accent Alpha", 25, "Sets the accent alpha of the Debug Menu.");
			DebugButtonColor = ClientSideConfigs.Bind<string>("New Debug", "Button Color", "#A447FF", "Sets the button color of the Debug Menu.");
			DebugButtonAlpha = ClientSideConfigs.Bind<int>("New Debug", "Button Alpha", 80, "Sets the button alpha of the Debug Menu.");
			minHyperShake = BepInExConfig.Bind<float>("Hypershake", "HyperShake Min Force", 15f, "Changes the minimum that hypershake can move you.");
			Bald = ClientSideConfigs.Bind<bool>("New Debug", "Bald", false, "Bald");
			maxHyperShake = BepInExConfig.Bind<float>("Hypershake", "HyperShake Max Force", 60f, "Changes the maximum that hypershake can move you.");
			LoversOnStart = BepInExConfig.Bind<bool>("Misc", "Lovers On Start", false, "Assigns New Lovers on each round");
			insideJoke = BepInExConfig.Bind<bool>("Misc", "Inside Joke", false, "Turns on inside jokes for stuff");
			aprilFoolsConfig = BepInExConfig.Bind<bool>("Misc", "April Fools", false, "Toggles april fools mode");
			CopyrightFree = ClientSideConfigs.Bind<bool>("Clientside", "Copyright Free", false, "Removes Copyright sounds over 10 seconds");
			CopyrightFree.SettingChanged += freebirdChange;
			SoundVolume = ClientSideConfigs.Bind<float>("Clientside", "Sound Volume", 0.75f, "Sets the volume for most sounds/music from this mod");
			SoundVolume.SettingChanged += setAudio;
			hyperShakeTimer = BepInExConfig.Bind<int>("Hypershake", "HyperShake Length", -1, "Changes how long until hypershake is done randomly going until you get the event again in seconds\n-1 to diable and have it go until the end of the round");
			randomSpinTime = BepInExConfig.Bind<bool>("Misc", "Have a random spin time", true, "Makes the dice spin a random amount of time before rolling.");
			chronosUpdatedTimeOfDay = BepInExConfig.Bind<bool>("Misc", "Updated Chronos Time", true, "Makes the Chronos die have better odds in the morning instead of equal odds in the morning.");
			doDiceExplosion = BepInExConfig.Bind<bool>("Misc", "Do Dice Explosion", true, "If the dice explode after rolling or not");
			TwitchEnabled = BepInExConfig.Bind<bool>("Twitch", "Enable Twitch Integration", false, "If Dice Twitch Integration is enabled (Needs TwitchChatAPI)");
			useDiceOutside = BepInExConfig.Bind<bool>("Misc", "Use Dice Outside", false, "Allows the use of the Chronos and Gambler outside.");
			allowChatCommands = BepInExConfig.Bind<bool>("Admin", "Allow chat commands", false, "Enables chat commands for the admin. Mainly for debugging.");
			eggExplodeTime = BepInExConfig.Bind<float>("Misc", "Egg Fountain Time", 0.25f, "Sets how quickly each egg explodes in the fountain, set to 0 for all explode instantly");
			yippeeUse = BepInExConfig.Bind<bool>("Misc", "Yippee Use Dice", false, "Makes it to where Hoarding bugs can use dice or not");
			minNeckSpin = BepInExConfig.Bind<float>("NeckSpin", "NeckSpin Min Speed", 0.1f, "Changes the minimum speed that your neck can spin.");
			maxNeckSpin = BepInExConfig.Bind<float>("NeckSpin", "NeckSpin Max Speed", 0.8f, "Changes the maximum speed that your neck can spin. ");
			neckRotations = BepInExConfig.Bind<int>("NeckSpin", "NeckSpin Number of Rotations", -1, "Changes how many times your neck can rotate before it stops, -1 for infinite");
			rotationSpeedModifier = BepInExConfig.Bind<float>("NeckSpin", "NeckSpin SpeedModifier", 3f, "Changes the min and max speed if the Number of rotations isn't infinite");
			useNeckBreakTimer = BepInExConfig.Bind<bool>("NeckBreak", "Use Timer", true, "Use a timer for neck break instead of until the end of the round");
			CustomEnemyEventCount = BepInExConfig.Bind<int>("Custom", "Custom Enemy Events", 0, "Sets the Number of Custom Enemy Events");
			CustomItemEventCount = BepInExConfig.Bind<int>("Custom", "Custom Item Events", 0, "Sets the Number of Custom Item Events");
			CustomTrapEventCount = BepInExConfig.Bind<int>("Custom", "Custom Trap Events", 0, "Sets the Number of Custom Trap Events");
			showOwnScanNode = ClientSideConfigs.Bind<bool>("Clientside", "Show own Scan Node", true, "Makes it to where you can see your own scan node or not (only affects certain people for now)");
			showOwnScanNode.SettingChanged += delegate
			{
				Misc.ToggleAllScanPlayerNodes();
			};
			minNeckBreakTimer = BepInExConfig.Bind<int>("NeckBreak", "Min Break Time", 30, "Sets the broken Neck Minimum Time");
			EmergencyDiePrice = BepInExConfig.Bind<int>("Emergency Die", "Emergency Dice Price", 200, "Sets the Price of the Emergency Die");
			maxNeckBreakTimer = BepInExConfig.Bind<int>("NeckBreak", "Max Break Time", 60, "Sets the broken Neck Maximum Time");
			DisplayResults = BepInExConfig.Bind<string>("Misc", "Display Results", DieBehaviour.ShowEffect.ALL.ToString(), "Display the dice results or not:\nALL - Shows all, NONE - shows none,\nDEFAULT - shows the default ones, RANDOM - randomly shows them");
			DebugLogging = BepInExConfig.Bind<bool>("Admin", "Debug Logging", false, "This is so I can see what the names of a lot of things are, probably not useful for most people");
			DebugMenuClosesAfter = BepInExConfig.Bind<bool>("Misc", "Debug Menu Closes After", true, "Makes it to where the debug menu closes after selecting an effect, False to stay open");
			toggleCursed = BepInExConfig.Bind<bool>("Misc", "ToggleCursed", false, "If set to true makes the cursed IDs and cursed randomly actually do stuff :D");
			cursedIDs = BepInExConfig.Bind<string>("Misc", "Cursed IDs", "76561198984467725", "Curses players whose steam IDs you put in here seperated by a comma");
			cursedRandomly = BepInExConfig.Bind<bool>("Misc", "Cursed Randomly", false, "Makes it to where random players are picked every quota for curses instead of the Cursed IDs List");
			BrutalMode = BepInExConfig.Bind<bool>("Brutal", "Brutal Mode", false, "Makes it to where the Random Dice Events Happen at the start of the round\nThis was Requested by a friend");
			BrutalChat = BepInExConfig.Bind<bool>("Brutal", "Brutal Chat", true, "Makes it to where the Brutal Events show in chat");
			SuperBrutalMode = BepInExConfig.Bind<bool>("Brutal", "Super Brutal Mode", false, "Makes it to where the Random Dice Events Happen randomly");
			brutalStartingScale = BepInExConfig.Bind<int>("Brutal", "Brutal Starting Scale", 1, "How many events it starts with");
			brutalMaxScale = BepInExConfig.Bind<int>("Brutal", "Brutal Max Scale", 7, "Sets the Max number of events it starts with");
			brutalScaleType = BepInExConfig.Bind<int>("Brutal", "Brutal Scale Type", 0, "Sets how it scales\n0: Scales based off how many days, maxing out at 50 days\n1: Scales based off how much scrap is on the ship\n2: Scales based off how many days survived in a row\n3: Scales based off a combo of 0 and 1\n4: Disable Scaling");
		}

		public static void setAudio(object sender, EventArgs e)
		{
			if ((Object)(object)Networker.Instance == (Object)null)
			{
				return;
			}
			foreach (AudioSource audioSource in Networker.Instance.AudioSources)
			{
				audioSource.volume = SoundVolume.Value;
			}
			foreach (AudioSource freebirdAudioSource in Networker.Instance.FreebirdAudioSources)
			{
				freebirdAudioSource.volume = SoundVolume.Value;
			}
		}

		public static void freebirdChange(object sender, EventArgs e)
		{
			if ((Object)(object)Networker.Instance == (Object)null)
			{
				return;
			}
			foreach (AudioSource freebirdAudioSource in Networker.Instance.FreebirdAudioSources)
			{
				if (CopyrightFree.Value)
				{
					freebirdAudioSource.clip = LoadedAssets2.LoadAsset<AudioClip>("SpazzmaticaPolka");
				}
				else
				{
					freebirdAudioSource.clip = LoadedAssets2.LoadAsset<AudioClip>("Freebird");
				}
				freebirdAudioSource.Play();
			}
		}

		public static List<ConfigEntryBase> GetListConfigs()
		{
			List<ConfigEntryBase> list = new List<ConfigEntryBase>();
			list.Add((ConfigEntryBase)(object)debugChat);
			list.Add((ConfigEntryBase)(object)superDebugMode);
			list.Add((ConfigEntryBase)(object)DieEmergencyAsScrap);
			list.Add((ConfigEntryBase)(object)EmergencyDiePrice);
			list.Add((ConfigEntryBase)(object)hyperShakeTimer);
			list.Add((ConfigEntryBase)(object)minHyperShake);
			list.Add((ConfigEntryBase)(object)maxHyperShake);
			list.Add((ConfigEntryBase)(object)randomSpinTime);
			list.Add((ConfigEntryBase)(object)chronosUpdatedTimeOfDay);
			list.Add((ConfigEntryBase)(object)useDiceOutside);
			list.Add((ConfigEntryBase)(object)allowChatCommands);
			list.Add((ConfigEntryBase)(object)minNeckSpin);
			list.Add((ConfigEntryBase)(object)maxNeckSpin);
			list.Add((ConfigEntryBase)(object)neckRotations);
			list.Add((ConfigEntryBase)(object)rotationSpeedModifier);
			list.Add((ConfigEntryBase)(object)useNeckBreakTimer);
			list.Add((ConfigEntryBase)(object)minNeckBreakTimer);
			list.Add((ConfigEntryBase)(object)maxNeckBreakTimer);
			list.Add((ConfigEntryBase)(object)DisplayResults);
			return list;
		}

		private void Awake()
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			directoryPath = Path.Combine(Application.persistentDataPath, "EmergencyDiceUpdated");
			CustomLogger = Logger.CreateLogSource("Emergency Dice Updated");
			if (!Directory.Exists(directoryPath))
			{
				Directory.CreateDirectory(directoryPath);
			}
			lethalThingsPresent = IsModPresent("evaisa.lethalthings", "LethalThings compatibility enabled!");
			LethalMonPresent = IsModPresent("LethalMon", "LethalMon compatibility enabled!");
			LCOfficePresent = IsModPresent("Piggy.LCOffice", "LCOffice compatibility enabled!");
			SurfacedPresent = IsModPresent("Surfaced", "Surfaced compatibility enabled!");
			LCTarotCardPresent = IsModPresent("LCTarotCard", "LCTarotCard compatibility enabled!");
			TakeyPlushPresent = IsModPresent("com.github.zehsteam.TakeyPlush", "TakeyPlush compatibility enabled!");
			CodeRebirthPresent = IsModPresent("CodeRebirth", "CodeRebirth compatibility enabled!");
			DiversityPresent = IsModPresent("Chaos.Diversity", "Diversity: Remastered compatibility enabled!");
			BombCollarPresent = IsModPresent("Jordo.BombCollar", "Bomb Collar compatibility enabled! >:)");
			NavMeshInCompanyPresent = IsModPresent("dev.kittenji.NavMeshInCompany", "Nav Mesh In Company compatibility enabled! >:)");
			NightOfTheLivingMimicPresent = IsModPresent("Slayer6409.NightOfTheLivingMimic", ">:)");
			TooManyEmotesPresent = IsModPresent("FlipMods.TooManyEmotes", "Dancing Enabled!");
			if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
			{
				LethalConfigPresent = true;
			}
			BepInExConfig = new ConfigFile(Path.Combine(Paths.ConfigPath, "Emergency Dice.cfg"), true);
			ClientSideConfigs = new ConfigFile(Path.Combine(directoryPath, "Emergency Dice ClientSide.cfg"), true);
			ModConfig();
			InvisibleEnemy.Config();
			BlameGlitch.Config();
			AlarmCurse.Config();
			if (SurfacedPresent)
			{
				Flinger.Config();
			}
			customCfg = new CustomConfigs(BepInExConfig);
			customCfg.GenerateConfigs(CustomEnemyEventCount.Value, CustomItemEventCount.Value, CustomTrapEventCount.Value);
			DieBehaviour.Config();
			if (superDebugMode.Value)
			{
				db();
			}
			LoadedAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "mysterydice"));
			LoadedAssets2 = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "mysterydice2"));
			sounds.Add("MineDetonate", LoadedAssets.LoadAsset<AudioClip>("MineDetonate"));
			sounds.Add("MineTrigger", LoadedAssets.LoadAsset<AudioClip>("MineTrigger"));
			sounds.Add("Bell2", LoadedAssets.LoadAsset<AudioClip>("Bell2"));
			sounds.Add("Bad1", LoadedAssets.LoadAsset<AudioClip>("Bad1"));
			sounds.Add("Good2", LoadedAssets.LoadAsset<AudioClip>("Good2"));
			sounds.Add("glitch", LoadedAssets.LoadAsset<AudioClip>("glitch"));
			sounds.Add("purr", LoadedAssets.LoadAsset<AudioClip>("purr"));
			sounds.Add("alarmcurse", LoadedAssets.LoadAsset<AudioClip>("alarmcurse"));
			sounds.Add("Meeting_Sound", LoadedAssets2.LoadAsset<AudioClip>("Meeting_Sound"));
			sounds.Add("Dawg", LoadedAssets2.LoadAsset<AudioClip>("Dawg"));
			sounds.Add("Jaws", LoadedAssets2.LoadAsset<AudioClip>("Jaws"));
			sounds.Add("FireAlarm", LoadedAssets2.LoadAsset<AudioClip>("FireAlarm"));
			sounds.Add("Paparazzi", LoadedAssets2.LoadAsset<AudioClip>("Paparazzi"));
			sounds.Add("WindowsError", LoadedAssets2.LoadAsset<AudioClip>("WindowsError"));
			sounds.Add("disconnect", LoadedAssets2.LoadAsset<AudioClip>("disconnect"));
			sounds.Add("DoorLeft", LoadedAssets2.LoadAsset<AudioClip>("DoorLeft"));
			sounds.Add("DoorRight", LoadedAssets2.LoadAsset<AudioClip>("DoorRight"));
			sounds.Add("AudioTest", LoadedAssets2.LoadAsset<AudioClip>("AudioTest"));
			sounds.Add("aot", LoadedAssets2.LoadAsset<AudioClip>("aot"));
			sounds.Add("wiwiwi", LoadedAssets2.LoadAsset<AudioClip>("wiwiwi"));
			sounds.Add("BANANA", LoadedAssets2.LoadAsset<AudioClip>("BANANA"));
			sounds.Add("tuturu", LoadedAssets2.LoadAsset<AudioClip>("tuturu"));
			sounds.Add("mah-boi", LoadedAssets2.LoadAsset<AudioClip>("mah-boi"));
			sounds.Add("Bad Romance", LoadedAssets2.LoadAsset<AudioClip>("bad"));
			sounds.Add("Boom", LoadedAssets2.LoadAsset<AudioClip>("boom"));
			sounds.Add("Bald", LoadedAssets2.LoadAsset<AudioClip>("Glitchimnotbald"));
			sounds.Add("BerthaCollide", LoadedAssets2.LoadAsset<AudioClip>("BerthaCollide"));
			sounds.Add("Jimothy", LoadedAssets2.LoadAsset<AudioClip>("JimHonk"));
			sounds.Add("Beartrap", LoadedAssets2.LoadAsset<AudioClip>("BearTrapSnapOnPlayer"));
			sounds.Add("JanitorBald", LoadedAssets2.LoadAsset<AudioClip>("JanitorIdleSpeak12"));
			sounds.Add("Duck", LoadedAssets2.LoadAsset<AudioClip>("DuckSpawn"));
			sounds.Add("Fumo", LoadedAssets2.LoadAsset<AudioClip>("Fumo"));
			sounds.Add("Steve", LoadedAssets2.LoadAsset<AudioClip>("Steve"));
			sounds.Add("Yeehaw", LoadedAssets2.LoadAsset<AudioClip>("Yeehaw"));
			sounds.Add("KeepDice", LoadedAssets2.LoadAsset<AudioClip>("KeepDice"));
			sounds.Add("NancyHair", LoadedAssets2.LoadAsset<AudioClip>("NancySorryGlitch"));
			sounds.Add("Lizard", LoadedAssets2.LoadAsset<AudioClip>("lizard"));
			sounds.Add("JackOLanternHit", LoadedAssets2.LoadAsset<AudioClip>("JackOLanternHit"));
			sounds.Add("NotAFish", LoadedAssets2.LoadAsset<AudioClip>("NotAFish"));
			sounds.Add("IAmFish", LoadedAssets2.LoadAsset<AudioClip>("IAmFish"));
			sounds.Add("GlobalDeathSound", LoadedAssets2.LoadAsset<AudioClip>("GlobalDeathSound"));
			sounds.Add("FishProof", LoadedAssets2.LoadAsset<AudioClip>("FishProof"));
			sounds.Add("FishSpeaking", LoadedAssets2.LoadAsset<AudioClip>("FishSpeaking"));
			WarningBracken = LoadedAssets.LoadAsset<Sprite>("bracken");
			WarningJester = LoadedAssets.LoadAsset<Sprite>("jester");
			WarningDeath = LoadedAssets.LoadAsset<Sprite>("death");
			WarningLuck = LoadedAssets.LoadAsset<Sprite>("luck");
			jobApplication = LoadedAssets2.LoadAsset<Material>("JobApplication");
			angyGlitch = LoadedAssets2.LoadAsset<Material>("AngyGlitch");
			angyFish = LoadedAssets2.LoadAsset<Material>("FishierAndAngrier");
			DiceGal = LoadedAssets2.LoadAsset<GameObject>("DiceGal");
			diceGalUnlockable = LoadedAssets2.LoadAsset<UnlockableItemDef>("DiceGalUnlockable");
			NetworkerPrefab = LoadedAssets.LoadAsset<GameObject>("Networker");
			((Object)NetworkerPrefab).name = "DiceNetworker";
			NetworkerPrefab.AddComponent<Networker>();
			AgentObjectPrefab = LoadedAssets2.LoadAsset<GameObject>("AgentObject");
			if (aprilFoolsConfig.Value)
			{
				AgentObjectPrefab.GetComponent<NavMeshAgent>().speed = 9f;
			}
			DebugMenuPrefab = LoadedAssets2.LoadAsset<GameObject>("DebugMenu");
			NewSelectMenuPrefab = LoadedAssets2.LoadAsset<GameObject>("NewSelectMenu");
			DebugMenuButtonPrefab = LoadedAssets2.LoadAsset<GameObject>("DebugButton");
			DebugSubButtonPrefab = LoadedAssets2.LoadAsset<GameObject>("SubmenuButton");
			PlayerNodeController = LoadedAssets2.LoadAsset<GameObject>("PlayerNodeController");
			JumpscareCanvasPrefab = LoadedAssets2.LoadAsset<GameObject>("JumpscareCanvas");
			JumpscareCanvasPrefab.AddComponent<Jumpscare>();
			SpiderCanvasPrefab = LoadedAssets2.LoadAsset<GameObject>("SpiderCanvas");
			SpiderMoverPrefab = LoadedAssets2.LoadAsset<GameObject>("SpiderMover");
			PathfinderPrefab = LoadedAssets.LoadAsset<GameObject>("Pathfinder");
			PathfinderPrefab.AddComponent<Pathfinder.PathfindBehaviour>();
			PathfinderSpawner = LoadedAssets.LoadAsset<Item>("Pathblob");
			Pathfinder.BlobspawnerBehaviour blobspawnerBehaviour = PathfinderSpawner.spawnPrefab.AddComponent<Pathfinder.BlobspawnerBehaviour>();
			((GrabbableObject)blobspawnerBehaviour).grabbable = true;
			((GrabbableObject)blobspawnerBehaviour).grabbableToEnemies = true;
			((GrabbableObject)blobspawnerBehaviour).itemProperties = PathfinderSpawner;
			NetworkPrefabs.RegisterNetworkPrefab(NetworkerPrefab);
			NetworkPrefabs.RegisterNetworkPrefab(AgentObjectPrefab);
			NetworkPrefabs.RegisterNetworkPrefab(PathfinderSpawner.spawnPrefab);
			NetworkPrefabs.RegisterNetworkPrefab(PathfinderPrefab);
			NetworkPrefabs.RegisterNetworkPrefab(DiceGal);
			NetworkPrefabs.RegisterNetworkPrefab(diceGalUnlockable.unlockable.prefabObject);
			if ((Object)(object)diceGalUnlockable == (Object)null)
			{
				CustomLogger.LogError((object)"DiceGalUnlockable is null!");
			}
			if (!DisableGal.Value)
			{
				Unlockables.RegisterUnlockable(diceGalUnlockable, GalPrice.Value, (StoreType)1);
			}
			LoadDice();
			Keybinds = new IngameKeybinds();
			Keybinds.DebugMenu.performed += delegate
			{
				DebugMenu();
			};
			harmony.PatchAll();
			if (LethalConfigPresent)
			{
				ConfigManager.setupLethalConfig();
			}
			CustomLogger.LogInfo((object)"The Emergency Dice mod was initialized!");
		}

		public static void RegisterNewEffect(IEffect effect, bool defaultOff = false, bool superDebug = false)
		{
			if (superDebug)
			{
				DieBehaviour.CompleteEffects.Add(effect);
			}
			else
			{
				DieBehaviour.AllEffects.Add(effect);
				DieBehaviour.CompleteEffects.Add(effect);
				ConfigEntry<bool> val = ((!defaultOff) ? BepInExConfig.Bind<bool>("Module Effects", effect.Name, true, effect.Tooltip) : BepInExConfig.Bind<bool>("Module Effects", effect.Name, false, effect.Tooltip));
				ConfigEntry<bool> val2 = BepInExConfig.Bind<bool>("Favorites", effect.Name, false, effect.Tooltip);
				DieBehaviour.effectConfigs.Add(val);
				if (val.Value)
				{
					DieBehaviour.AllowedEffects.Add(effect);
					switch (effect.Outcome)
					{
					case EffectType.Awful:
						DieBehaviour.AwfulEffects.Add(effect);
						break;
					case EffectType.Bad:
						DieBehaviour.BadEffects.Add(effect);
						break;
					case EffectType.Mixed:
						DieBehaviour.MixedEffects.Add(effect);
						break;
					case EffectType.Good:
						DieBehaviour.GoodEffects.Add(effect);
						break;
					case EffectType.Great:
						DieBehaviour.GreatEffects.Add(effect);
						break;
					}
				}
				if (LethalConfigPresent)
				{
					ConfigManager.addConfig(val);
				}
			}
			DieBehaviour.AllEffects = DieBehaviour.AllEffects.OrderBy((IEffect o) => o.Name).ToList();
			DieBehaviour.CompleteEffects = DieBehaviour.CompleteEffects.OrderBy((IEffect o) => o.Name).ToList();
		}

		internal static void MainRegisterNewEffect(IEffect effect, bool defaultOff = false, bool superDebug = false)
		{
			if (superDebug)
			{
				DieBehaviour.CompleteEffects.Add(effect);
				return;
			}
			DieBehaviour.AllEffects.Add(effect);
			ConfigEntry<bool> val = ((!defaultOff) ? BepInExConfig.Bind<bool>("Allowed Effects", effect.Name, true, effect.Tooltip) : BepInExConfig.Bind<bool>("Allowed Effects", effect.Name, false, effect.Tooltip));
			ConfigEntry<bool> val2 = BepInExConfig.Bind<bool>("Favorites", effect.Name, false, effect.Tooltip);
			DieBehaviour.effectConfigs.Add(val);
			if (!val.Value)
			{
				return;
			}
			if (effect is GalEffect item)
			{
				DiceGalAI.GalEffects.Add(item);
				if (DisableGal.Value)
				{
					DieBehaviour.AllowedEffects.Add(item);
				}
			}
			else
			{
				DieBehaviour.AllowedEffects.Add(effect);
			}
			switch (effect.Outcome)
			{
			case EffectType.Awful:
				DieBehaviour.AwfulEffects.Add(effect);
				break;
			case EffectType.Bad:
				DieBehaviour.BadEffects.Add(effect);
				break;
			case EffectType.Mixed:
				DieBehaviour.MixedEffects.Add(effect);
				break;
			case EffectType.Good:
				DieBehaviour.GoodEffects.Add(effect);
				break;
			case EffectType.Great:
				DieBehaviour.GreatEffects.Add(effect);
				break;
			}
		}

		private void db()
		{
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				CustomLogger.LogInfo((object)$"{pluginInfo}");
			}
		}

		public static void DebugMenu(bool bypassButton = false)
		{
			TryRequestAdmin();
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			bool flag = localPlayerController.playerSteamId == slayerSteamID;
			bool isHost = ((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsHost;
			bool flag2 = (Object)(object)Networker.Instance != (Object)null && canOpenAdminMenu();
			bool completes = superDebugMode.Value || flag;
			if ((debugButton.Value || flag) && flag2)
			{
				if (flag)
				{
					DebugMenuStuff.showDebugMenu(fulls: true, completes: true, sus: true);
				}
				else if (isHost)
				{
					DebugMenuStuff.showDebugMenu(BetterDebugMenu.Value, completes, sus: true);
				}
				else
				{
					DebugMenuStuff.showDebugMenu(BetterDebugMenu.Value, completes: false, isHost);
				}
			}
		}

		public static bool canOpenAdminMenu()
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			ulong playerSteamId = localPlayerController.playerSteamId;
			return playerSteamId == slayerSteamID || ((NetworkBehaviour)localPlayerController).IsHost || isAdmin;
		}

		public static void TryRequestAdmin()
		{
			if (!triedRequestingAdmin && !isAdmin)
			{
				PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
				if ((Object)(object)localPlayerController != (Object)null)
				{
					triedRequestingAdmin = true;
					ulong playerSteamId = localPlayerController.playerSteamId;
					Networker.Instance.RequestAdminStateServerRpc(playerSteamId);
				}
			}
		}

		private static bool IsModPresent(string name, string logMessage)
		{
			bool flag = Chainloader.PluginInfos.ContainsKey(name);
			if (flag)
			{
				CustomLogger.LogMessage((object)logMessage);
			}
			return flag;
		}

		public static void ExtendedLogging(string logMessage, LogLevel level = (LogLevel)16)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (DebugLogging.Value)
			{
				CustomLogger.Log(level, (object)logMessage);
			}
		}

		public static void LoadDice()
		{
			//IL_1399: Unknown result type (might be due to invalid IL or missing references)
			sounds.TryGetValue("JackOLanternHit", out var value);
			DieSteve = LoadedAssets2.LoadAsset<Item>("stevedieitem");
			DieSteve.canBeGrabbedBeforeGameStart = true;
			SteveLeDice component = DieSteve.spawnPrefab.GetComponent<SteveLeDice>();
			component.myType = DieBehaviour.DiceType.STEVE;
			((GrabbableObject)component).grabbable = true;
			((GrabbableObject)component).grabbableToEnemies = true;
			((GrabbableObject)component).itemProperties = DieSteve;
			RegisteredDice.Add(DieSteve);
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieSteve.dropSFX = value;
			}
			DieCodeRebirth = LoadedAssets2.LoadAsset<Item>("coderebirthdieitem");
			DieCodeRebirth.minValue = 150;
			DieCodeRebirth.maxValue = 210;
			DieCodeRebirth.canBeGrabbedBeforeGameStart = true;
			CodeRebirthDie codeRebirthDie = DieCodeRebirth.spawnPrefab.AddComponent<CodeRebirthDie>();
			codeRebirthDie.myType = DieBehaviour.DiceType.CODEREBIRTH;
			((GrabbableObject)codeRebirthDie).grabbable = true;
			((GrabbableObject)codeRebirthDie).grabbableToEnemies = true;
			((GrabbableObject)codeRebirthDie).itemProperties = DieCodeRebirth;
			RegisteredDice.Add(DieCodeRebirth);
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieCodeRebirth.dropSFX = value;
			}
			DieSurfaced = LoadedAssets2.LoadAsset<Item>("surfaceddieitem");
			DieSurfaced.minValue = 150;
			DieSurfaced.maxValue = 210;
			DieSurfaced.canBeGrabbedBeforeGameStart = true;
			SurfacedDie surfacedDie = DieSurfaced.spawnPrefab.AddComponent<SurfacedDie>();
			surfacedDie.myType = DieBehaviour.DiceType.SURFACED;
			((GrabbableObject)surfacedDie).grabbable = true;
			((GrabbableObject)surfacedDie).grabbableToEnemies = true;
			((GrabbableObject)surfacedDie).itemProperties = DieSurfaced;
			RegisteredDice.Add(DieSurfaced);
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieSurfaced.dropSFX = value;
			}
			DieEmergency = LoadedAssets.LoadAsset<Item>("Emergency Dice Script");
			DieEmergency.highestSalePercentage = 80;
			DieEmergency.canBeGrabbedBeforeGameStart = true;
			EmergencyDie emergencyDie = DieEmergency.spawnPrefab.AddComponent<EmergencyDie>();
			emergencyDie.myType = DieBehaviour.DiceType.EMERGENCY;
			((GrabbableObject)emergencyDie).grabbable = true;
			((GrabbableObject)emergencyDie).grabbableToEnemies = true;
			((GrabbableObject)emergencyDie).itemProperties = DieEmergency;
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieEmergency.dropSFX = value;
			}
			RegisteredDice.Add(DieEmergency);
			DieChronos = LoadedAssets.LoadAsset<Item>("Chronos");
			DieChronos.minValue = 120;
			DieChronos.maxValue = 140;
			DieChronos.canBeGrabbedBeforeGameStart = true;
			ChronosDie chronosDie = DieChronos.spawnPrefab.AddComponent<ChronosDie>();
			chronosDie.myType = DieBehaviour.DiceType.CHRONOS;
			((GrabbableObject)chronosDie).grabbable = true;
			((GrabbableObject)chronosDie).grabbableToEnemies = true;
			((GrabbableObject)chronosDie).itemProperties = DieChronos;
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieChronos.dropSFX = value;
			}
			RegisteredDice.Add(DieChronos);
			DieGambler = LoadedAssets2.LoadAsset<Item>("GamblerItem");
			DieGambler.minValue = 100;
			DieGambler.maxValue = 130;
			DieGambler.canBeGrabbedBeforeGameStart = true;
			GamblerDie gamblerDie = DieGambler.spawnPrefab.AddComponent<GamblerDie>();
			gamblerDie.myType = DieBehaviour.DiceType.GAMBLER;
			((GrabbableObject)gamblerDie).grabbable = true;
			((GrabbableObject)gamblerDie).grabbableToEnemies = true;
			((GrabbableObject)gamblerDie).itemProperties = DieGambler;
			RegisteredDice.Add(DieGambler);
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieGambler.dropSFX = value;
			}
			DieSacrificer = LoadedAssets2.LoadAsset<Item>("SacrificerItem");
			DieSacrificer.minValue = 170;
			DieSacrificer.maxValue = 230;
			DieSacrificer.canBeGrabbedBeforeGameStart = true;
			SacrificerDie sacrificerDie = DieSacrificer.spawnPrefab.AddComponent<SacrificerDie>();
			sacrificerDie.myType = DieBehaviour.DiceType.SACRIFICER;
			((GrabbableObject)sacrificerDie).grabbable = true;
			((GrabbableObject)sacrificerDie).grabbableToEnemies = true;
			((GrabbableObject)sacrificerDie).itemProperties = DieSacrificer;
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieSacrificer.dropSFX = value;
			}
			RegisteredDice.Add(DieSacrificer);
			DieSaint = LoadedAssets.LoadAsset<Item>("Saint");
			DieSaint.minValue = 210;
			DieSaint.maxValue = 280;
			DieSaint.canBeGrabbedBeforeGameStart = true;
			SaintDie saintDie = DieSaint.spawnPrefab.AddComponent<SaintDie>();
			saintDie.myType = DieBehaviour.DiceType.SAINT;
			((GrabbableObject)saintDie).grabbable = true;
			((GrabbableObject)saintDie).grabbableToEnemies = true;
			((GrabbableObject)saintDie).itemProperties = DieSaint;
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieSaint.dropSFX = value;
			}
			RegisteredDice.Add(DieSaint);
			DieRusty = LoadedAssets2.LoadAsset<Item>("RustyItem");
			DieRusty.minValue = 90;
			DieRusty.maxValue = 160;
			DieRusty.canBeGrabbedBeforeGameStart = true;
			RustyDie rustyDie = DieRusty.spawnPrefab.AddComponent<RustyDie>();
			rustyDie.myType = DieBehaviour.DiceType.RUSTY;
			((GrabbableObject)rustyDie).grabbable = true;
			((GrabbableObject)rustyDie).grabbableToEnemies = true;
			((GrabbableObject)rustyDie).itemProperties = DieRusty;
			if (isHalloween && (Object)(object)value != (Object)null)
			{
				DieRusty.dropSFX = value;
			}
			RegisteredDice.Add(DieRusty);
			if (EmergencyDiePrice.Value >= 0)
			{
				TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
				val.clearPreviousText = true;
				val.displayText = "This handy, unstable device might be your last chance to save yourself.\n\nRolls a number from 1 to 6:\n-Rolling 6 teleports you and players standing closely near you to the ship with all your items.\n-Rolling 4 or 5 teleports you to the ship with all your items.\n-Rolling 3 might be bad, or might be good. You decide? \n-Rolling 2 will causes some problems\n-You dont want to roll a 1\n";
				Items.RegisterShopItem(DieEmergency, (TerminalNode)null, (TerminalNode)null, val, EmergencyDiePrice.Value);
			}
			Dictionary<(string, string), int> dictionary = new Dictionary<(string, string), int>
			{
				{
					(DieSteve.itemName, "Default"),
					25
				},
				{
					(DieSteve.itemName, "Experimentation"),
					16
				},
				{
					(DieSteve.itemName, "Assurance"),
					26
				},
				{
					(DieSteve.itemName, "Vow"),
					25
				},
				{
					(DieSteve.itemName, "Offense"),
					17
				},
				{
					(DieSteve.itemName, "March"),
					27
				},
				{
					(DieSteve.itemName, "Rend"),
					26
				},
				{
					(DieSteve.itemName, "Dine"),
					36
				},
				{
					(DieSteve.itemName, "Titan"),
					25
				},
				{
					(DieSteve.itemName, "Adamance"),
					15
				},
				{
					(DieSteve.itemName, "Artifice"),
					28
				},
				{
					(DieSteve.itemName, "Embrion"),
					45
				},
				{
					(DieCodeRebirth.itemName, "Default"),
					25
				},
				{
					(DieCodeRebirth.itemName, "Experimentation"),
					16
				},
				{
					(DieCodeRebirth.itemName, "Assurance"),
					26
				},
				{
					(DieCodeRebirth.itemName, "Vow"),
					25
				},
				{
					(DieCodeRebirth.itemName, "Offense"),
					17
				},
				{
					(DieCodeRebirth.itemName, "March"),
					27
				},
				{
					(DieCodeRebirth.itemName, "Rend"),
					26
				},
				{
					(DieCodeRebirth.itemName, "Dine"),
					36
				},
				{
					(DieCodeRebirth.itemName, "Titan"),
					25
				},
				{
					(DieCodeRebirth.itemName, "Adamance"),
					15
				},
				{
					(DieCodeRebirth.itemName, "Artifice"),
					28
				},
				{
					(DieCodeRebirth.itemName, "Embrion"),
					45
				},
				{
					(DieSurfaced.itemName, "Default"),
					25
				},
				{
					(DieSurfaced.itemName, "Experimentation"),
					16
				},
				{
					(DieSurfaced.itemName, "Assurance"),
					26
				},
				{
					(DieSurfaced.itemName, "Vow"),
					25
				},
				{
					(DieSurfaced.itemName, "Offense"),
					17
				},
				{
					(DieSurfaced.itemName, "March"),
					27
				},
				{
					(DieSurfaced.itemName, "Rend"),
					26
				},
				{
					(DieSurfaced.itemName, "Dine"),
					36
				},
				{
					(DieSurfaced.itemName, "Titan"),
					25
				},
				{
					(DieSurfaced.itemName, "Adamance"),
					15
				},
				{
					(DieSurfaced.itemName, "Artifice"),
					28
				},
				{
					(DieSurfaced.itemName, "Embrion"),
					45
				},
				{
					(DieGambler.itemName, "Default"),
					25
				},
				{
					(DieGambler.itemName, "Experimentation"),
					13
				},
				{
					(DieGambler.itemName, "Assurance"),
					13
				},
				{
					(DieGambler.itemName, "Vow"),
					15
				},
				{
					(DieGambler.itemName, "Offense"),
					17
				},
				{
					(DieGambler.itemName, "March"),
					17
				},
				{
					(DieGambler.itemName, "Rend"),
					33
				},
				{
					(DieGambler.itemName, "Dine"),
					46
				},
				{
					(DieGambler.itemName, "Titan"),
					30
				},
				{
					(DieGambler.itemName, "Adamance"),
					21
				},
				{
					(DieGambler.itemName, "Artifice"),
					43
				},
				{
					(DieGambler.itemName, "Embrion"),
					60
				},
				{
					(DieChronos.itemName, "Default"),
					23
				},
				{
					(DieChronos.itemName, "Experimentation"),
					17
				},
				{
					(DieChronos.itemName, "Assurance"),
					17
				},
				{
					(DieChronos.itemName, "Vow"),
					17
				},
				{
					(DieChronos.itemName, "Offense"),
					25
				},
				{
					(DieChronos.itemName, "March"),
					25
				},
				{
					(DieChronos.itemName, "Rend"),
					22
				},
				{
					(DieChronos.itemName, "Dine"),
					41
				},
				{
					(DieChronos.itemName, "Titan"),
					33
				},
				{
					(DieChronos.itemName, "Adamance"),
					19
				},
				{
					(DieChronos.itemName, "Artifice"),
					40
				},
				{
					(DieChronos.itemName, "Embrion"),
					58
				},
				{
					(DieSacrificer.itemName, "Default"),
					20
				},
				{
					(DieSacrificer.itemName, "Experimentation"),
					20
				},
				{
					(DieSacrificer.itemName, "Assurance"),
					20
				},
				{
					(DieSacrificer.itemName, "Vow"),
					20
				},
				{
					(DieSacrificer.itemName, "Offense"),
					20
				},
				{
					(DieSacrificer.itemName, "March"),
					20
				},
				{
					(DieSacrificer.itemName, "Rend"),
					35
				},
				{
					(DieSacrificer.itemName, "Dine"),
					38
				},
				{
					(DieSacrificer.itemName, "Titan"),
					23
				},
				{
					(DieSacrificer.itemName, "Adamance"),
					20
				},
				{
					(DieSacrificer.itemName, "Artifice"),
					35
				},
				{
					(DieSacrificer.itemName, "Embrion"),
					41
				},
				{
					(DieSaint.itemName, "Default"),
					10
				},
				{
					(DieSaint.itemName, "Experimentation"),
					10
				},
				{
					(DieSaint.itemName, "Assurance"),
					10
				},
				{
					(DieSaint.itemName, "Vow"),
					10
				},
				{
					(DieSaint.itemName, "Offense"),
					10
				},
				{
					(DieSaint.itemName, "March"),
					10
				},
				{
					(DieSaint.itemName, "Rend"),
					12
				},
				{
					(DieSaint.itemName, "Dine"),
					15
				},
				{
					(DieSaint.itemName, "Titan"),
					12
				},
				{
					(DieSaint.itemName, "Adamance"),
					10
				},
				{
					(DieSaint.itemName, "Artifice"),
					15
				},
				{
					(DieSaint.itemName, "Embrion"),
					21
				},
				{
					(DieRusty.itemName, "Default"),
					18
				},
				{
					(DieRusty.itemName, "Experimentation"),
					15
				},
				{
					(DieRusty.itemName, "Assurance"),
					15
				},
				{
					(DieRusty.itemName, "Vow"),
					5
				},
				{
					(DieRusty.itemName, "Offense"),
					18
				},
				{
					(DieRusty.itemName, "March"),
					5
				},
				{
					(DieRusty.itemName, "Rend"),
					16
				},
				{
					(DieRusty.itemName, "Dine"),
					26
				},
				{
					(DieRusty.itemName, "Titan"),
					14
				},
				{
					(DieRusty.itemName, "Adamance"),
					16
				},
				{
					(DieRusty.itemName, "Artifice"),
					21
				},
				{
					(DieRusty.itemName, "Embrion"),
					38
				}
			};
			if (DieEmergencyAsScrap.Value)
			{
				DieEmergency.isScrap = true;
				dictionary.Add((DieEmergency.itemName, "Default"), 18);
				dictionary.Add((DieEmergency.itemName, "Experimentation"), 15);
				dictionary.Add((DieEmergency.itemName, "Assurance"), 15);
				dictionary.Add((DieEmergency.itemName, "Vow"), 5);
				dictionary.Add((DieEmergency.itemName, "Offense"), 18);
				dictionary.Add((DieEmergency.itemName, "March"), 5);
				dictionary.Add((DieEmergency.itemName, "Rend"), 16);
				dictionary.Add((DieEmergency.itemName, "Dine"), 26);
				dictionary.Add((DieEmergency.itemName, "Titan"), 14);
				dictionary.Add((DieEmergency.itemName, "Adamance"), 16);
				dictionary.Add((DieEmergency.itemName, "Artifice"), 21);
				dictionary.Add((DieEmergency.itemName, "Embrion"), 38);
			}
			foreach (Item registeredDie in RegisteredDice)
			{
				NetworkPrefabs.RegisterNetworkPrefab(registeredDie.spawnPrefab);
				Utilities.FixMixerGroups(registeredDie.spawnPrefab);
			}
			foreach (Item registeredDie2 in RegisteredDice)
			{
				if ((Object)(object)registeredDie2 == (Object)(object)DieEmergency && !DieEmergencyAsScrap.Value)
				{
					continue;
				}
				ConfigEntry<int> val2 = BepInExConfig.Bind<int>(registeredDie2.itemName + " Spawn rates", "Default", dictionary[(registeredDie2.itemName, "Default")], "Default spawn rate for all levels. Mainly for setting up spawn rates for either new beta moons or modded ones.");
				foreach (KeyValuePair<string, LevelTypes> regLevel in RegLevels)
				{
					ConfigEntry<int> val3 = BepInExConfig.Bind<int>(registeredDie2.itemName + " Spawn rates", regLevel.Key, dictionary[(registeredDie2.itemName, regLevel.Key)], "Sets how often this item spawns on this level. 0-10 is very rare, 10-25 is rare, 25+ is common. This is only from my observations. -Theronguard (These numbers are with no modded scrap from my observations - Slayer)");
					int num = val3.Value;
					if (aprilFoolsConfig.Value)
					{
						num *= 2;
					}
					Items.RegisterScrap(registeredDie2, num, regLevel.Value);
				}
				int num2 = val2.Value;
				if (aprilFoolsConfig.Value)
				{
					num2 *= 2;
				}
				Items.RegisterScrap(registeredDie2, num2, (LevelTypes)(-1));
			}
		}
	}
	public class Networker : NetworkBehaviour
	{
		[Serializable]
		public class PlayerScanData
		{
			public string top;

			public string bottom;

			public string bg;

			public string text;

			public bool isRainbow;
		}

		public static Networker Instance;

		internal static EntranceTeleport[] _entrancePoints = Array.Empty<EntranceTeleport>();

		public static float RebelTimer = 0f;

		public static bool CoilheadIgnoreStares = false;

		public static List<UnlockableSuit> orderedSuits = new List<UnlockableSuit>();

		public List<AudioSource> AudioSources = new List<AudioSource>();

		public List<AudioSource> FreebirdAudioSources = new List<AudioSource>();

		public List<ulong> cursedPeople = new List<ulong>();

		public List<GameObject> playerScanNodes = new List<GameObject>();

		public Dictionary<MaskedPlayerEnemy, MimicTracker> MimicTrackers = new Dictionary<MaskedPlayerEnemy, MimicTracker>();

		public readonly Dictionary<int, GameObject> scanNodesByPlayerIndex = new Dictionary<int, GameObject>();

		public static Dictionary<string, PlayerScanData> scanNodeData = new Dictionary<string, PlayerScanData>();

		public const string ScanDataUrl = "https://raw.githubusercontent.com/slayer6409/Emergency-Dice-Updated/refs/heads/master/docs/PlayerScanNodes.json?ver=";

		private Queue<(IEffect effect, string WhoRolled)> spawnQueue = new Queue<(IEffect, string)>();

		private bool twitchCanRoll = true;

		private int maxSpawnsPerFrame = 1;

		private static Vector2 TimerRange = new Vector2(3f, 6f);

		private static int PlayerIDToExplode;

		private static float ExplosionTimer = 0f;

		public Dictionary<PlayerControllerB, UnlockableSuit> playerToSuit = new Dictionary<PlayerControllerB, UnlockableSuit>();

		private Coroutine DoorMalfunctioning = null;

		public static IReadOnlyList<EntranceTeleport> EntrancePoints => _entrancePoints;

		public void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((UnityEvent)StartOfRound.Instance.StartNewRoundEvent).AddListener(new UnityAction(OnNewRoundStart));
			((MonoBehaviour)this).StartCoroutine(LoadScanDataFromURL("https://raw.githubusercontent.com/slayer6409/Emergency-Dice-Updated/refs/heads/master/docs/PlayerScanNodes.json?ver=" + Random.Range(0, 10000000), DefaultFallbackStuff));
		}

		private void ToggleScannode(int playerIndex)
		{
			scanNodesByPlayerIndex[playerIndex].gameObject.SetActive(!scanNodesByPlayerIndex[playerIndex].activeSelf);
		}

		private void DefaultFallbackStuff()
		{
			MysteryDice.CustomLogger.LogWarning((object)"Using fallback scan node data (GitHub JSON failed to load).");
			scanNodeData.Clear();
			scanNodeData["76561198984467725"] = new PlayerScanData
			{
				top = "Bald",
				bottom = "Shiny Head (Maybe a fish)",
				bg = "#00FF00",
				text = "#007B00",
				isRainbow = false
			};
			scanNodeData["76561198003293676"] = new PlayerScanData
			{
				top = "Short",
				bottom = "1 mm tall",
				bg = "#FF0000",
				text = "#3C0000",
				isRainbow = false
			};
			scanNodeData["76561199092131418"] = new PlayerScanData
			{
				top = "Stinky",
				bottom = "Eww Stinky",
				bg = "#0000FF",
				text = "#00FF00",
				isRainbow = false
			};
			scanNodeData["76561198077184650"] = new PlayerScanData
			{
				top = "Dice Man",
				bottom = "Sacrificer Broken",
				bg = "#000000",
				text = "#000000",
				isRainbow = true
			};
			scanNodeData["76561198216220844"] = new PlayerScanData
			{
				top = "Macho",
				bottom = "Macho Macho Macho",
				bg = "#9600FF",
				text = "#FF0000",
				isRainbow = false
			};
			scanNodeData["76561198399127090"] = new PlayerScanData
			{
				top = "Hi Mu!",
				bottom = " ",
				bg = "#ECBDC4",
				text = "#FA8AAA",
				isRainbow = false
			};
			scanNodeData["76561198195911589"] = new PlayerScanData
			{
				top = "Mu!",
				bottom = "Bald Birthday Girl",
				bg = "#ECBDC4",
				text = "#FA8AAA",
				isRainbow = false
			};
			scanNodeData["76561199094139351"] = new PlayerScanData
			{
				top = "Lizzie!",
				bottom = "Friends of the Blob",
				bg = "#EC14C4",
				text = "#FAB4AA",
				isRainbow = false
			};
			scanNodeData["76561198164429786"] = new PlayerScanData
			{
				top = "Boom Bird",
				bottom = "Go Scarab",
				bg = "#00FF00",
				text = "#000000",
				isRainbow = false
			};
			scanNodeData["76561198086086035"] = new PlayerScanData
			{
				top = "Suit Guy",
				bottom = "Makes Cool Suits",
				bg = "#8800B4",
				text = "#000000",
				isRainbow = false
			};
			scanNodeData["76561199062430236"] = new PlayerScanData
			{
				top = "Seraphi",
				bottom = "The Cryptid",
				bg = "#00BBFF",
				text = "#0032C3",
				isRainbow = false
			};
			scanNodeData["76561198154072417"] = new PlayerScanData
			{
				top = "Draga",
				bottom = "Titties that break things",
				bg = "#7814FF",
				text = "#000000",
				isRainbow = false
			};
			scanNodeData["76561198046185322"] = new PlayerScanData
			{
				top = "Dorje",
				bottom = "The Spray Master",
				bg = "#FF6E00",
				text = "#000000",
				isRainbow = false
			};
			scanNodeData["76561198291058317"] = new PlayerScanData
			{
				top = "Storm",
				bottom = "Glitch's Wife",
				bg = "#0000FF",
				text = "#000000",
				isRainbow = false
			};
			scanNodeData["76561198298676562"] = new PlayerScanData
			{
				top = "Jacu",
				bottom = "Gremlin Survivor",
				bg = "#BEBEBE",
				text = "#000000",
				isRainbow = false
			};
			scanNodeData["76561198067589770"] = new PlayerScanData
			{
				top = "Pepsi",
				bottom = "Lethal Evolved",
				bg = "#0000FF",
				text = "#FFFFFF",
				isRainbow = false
			};
			scanNodeData["76561199182474292"] = new PlayerScanData
			{
				top = "Rat",
				bottom = "Happy Birthday Rat",
				bg = "#000000",
				text = "#FFFFFF",
				isRainbow = false
			};
			scanNodeData["76561198993437314"] = new PlayerScanData
			{
				top = "Fumo",
				bottom = "Fumo Fumo Fumo",
				bg = "#B40028",
				text = "#000000",
				isRainbow = false
			};
			scanNodeData["76561198261033887"] = new PlayerScanData
			{
				top = "Kiszony",
				bottom = "Trite Lover",
				bg = "#FE6B02",
				text = "#FFFFFF",
				isRainbow = false
			};
			scanNodeData["76561198252920041"] = new PlayerScanData
			{
				top = "Al3m33da",
				bottom = "RAWRRRRRR",
				bg = "#FA8AAA",
				text = "#FFFFFF",
				isRainbow = false
			};
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			Instance = this;
			((MonoBehaviour)this).StartCoroutine(DelayStartup());
			string[] array = MysteryDice.cursedIDs.Value.Split(',');
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (!string.IsNullOrEmpty(text2) && ulong.TryParse(text2, out var result))
				{
					cursedPeople.Add(result);
				}
			}
			if (!((NetworkBehaviour)this).IsServer)
			{
				RequestSyncCursedServerRPC();
				DieBehaviour.AllowedEffects.Clear();
				((MonoBehaviour)this).StartCoroutine(SyncRequest());
			}
		}

		private static IEnumerator LoadScanDataFromURL(string url, Action fallback)
		{
			UnityWebRequest www = UnityWebRequest.Get(url);
			try
			{
				yield return www.SendWebRequest();
				if ((int)www.result != 1)
				{
					MysteryDice.CustomLogger.LogWarning((object)("Scan data load failed: " + www.error));
					fallback?.Invoke();
					yield break;
				}
				try
				{
					string json = www.downloadHandler.text;
					scanNodeData = JsonConvert.DeserializeObject<Dictionary<string, PlayerScanData>>(json);
					MysteryDice.CustomLogger.LogInfo((object)$"Loaded {scanNodeData.Count} scan entries.");
				}
				catch (Exception ex)
				{
					Exception e = ex;
					MysteryDice.CustomLogger.LogError((object)$"Scan JSON parse error: {e}");
					fallback?.Invoke();
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		public void DelaySuitGet()
		{
			orderedSuits = (from suit in Object.FindObjectsOfType<UnlockableSuit>()
				orderby (suit.syncedSuitID.Value >= 0 && suit.syncedSuitID.Value < StartOfRound.Instance.unlockablesList.unlockables.Count) ? StartOfRound.Instance.unlockablesList.unlockables[suit.syncedSuitID.Value].unlockableName : string.Empty
				select suit).ToList();
		}

		public IEnumerator DelayStartup()
		{
			yield return (object)new WaitForSeconds(3.5f);
			DelaySuitGet();
			((MonoBehaviour)this).StartCoroutine(ManyAds.LoadRemoteTextLists());
			AddControllerToPlayers();
		}

		public void resetAudioPlaces()
		{
			foreach (PlayerControllerB item in StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB x) => Misc.IsPlayerReal(x)))
			{
				if (!((NetworkBehaviour)item).IsLocalPlayer && !((Object)(object)item.currentVoiceChatAudioSource == (Object)null))
				{
					((Component)item.currentVoiceChatAudioSource).transform.SetParent(((Component)item).transform);
				}
			}
		}

		public void forceUpdatePlayers()
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB value in allPlayerScripts)
			{
				AddControllerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, value));
			}
		}

		public void AddControllerToPlayers()
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.IsLocalPlayer())
				{
					AddControllerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val));
				}
				else if (Misc.IsPlayerReal(val))
				{
					InstantiateSpecialPrefabForPlayer(val);
				}
			}
		}

		public void InstantiateSpecialPrefabForMimic(MaskedPlayerEnemy masked)
		{
			//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_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_01db: 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_01f8: 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_022a: 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_0233: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)masked == (Object)null || (Object)(object)masked.mimickingPlayer == (Object)null)
			{
				return;
			}
			PlayerControllerB mimickingPlayer = masked.mimickingPlayer;
			string text = "";
			string text2 = "";
			Color black = Color.black;
			Color black2 = Color.black;
			bool flag = false;
			string text3 = mimickingPlayer.playerSteamId.ToString();
			PlayerScanData value = null;
			if (!scanNodeData.TryGetValue(text3, out value))
			{
				string text4 = mimickingPlayer.playerUsername?.Trim() ?? string.Empty;
				MysteryDice.ExtendedLogging("[ScanNode] (Mimic) No SteamID match for " + text3 + ". Trying username key '" + text4 + "'. Known keys: " + string.Join(", ", scanNodeData.Keys), (LogLevel)16);
				if (!string.IsNullOrEmpty(text4) && scanNodeData.TryGetValue(text4, out var value2))
				{
					value = value2;
				}
			}
			if (value == null)
			{
				MysteryDice.ExtendedLogging("[ScanNode] (Mimic) No scan data found for steamID=" + text3 + " or username='" + mimickingPlayer.playerUsername + "'.", (LogLevel)16);
				return;
			}
			text = value.top;
			text2 = value.bottom;
			flag = value.isRainbow;
			ColorUtility.TryParseHtmlString(value.bg, ref black);
			ColorUtility.TryParseHtmlString(value.text, ref black2);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			GameObject playerNodeController = MysteryDice.PlayerNodeController;
			if (Object.op_Implicit((Object)(object)playerNodeController))
			{
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(0f, 2.5f, 0f);
				GameObject val2 = Object.Instantiate<GameObject>(playerNodeController, ((Component)masked).transform.position + val, Quaternion.identity);
				MimicTracker mimicTracker = val2.AddComponent<MimicTracker>();
				mimicTracker.init(masked, val);
				MimicTrackers.Add(masked, mimicTracker);
				ForceScanColorOnItem componentInChildren = val2.GetComponentInChildren<ForceScanColorOnItem>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.borderColor = black;
					componentInChildren.textColor = black2;
				}
				ScanNodeProperties componentInChildren2 = val2.GetComponentInChildren<ScanNodeProperties>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.headerText = text;
					componentInChildren2.subText = text2;
				}
				if (flag)
				{
					val2.AddComponent<RainbowScanNode>();
				}
				playerScanNodes.Add(val2);
			}
		}

		private void InstantiateSpecialPrefabForPlayer(PlayerControllerB player)
		{
			//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_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_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_0256: 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_0287: 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_028f: 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)
			string text = "";
			string subText = "";
			Color black = Color.black;
			Color black2 = Color.black;
			int num = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player);
			if (num < 0)
			{
				return;
			}
			if (scanNodesByPlayerIndex.TryGetValue(num, out var value) && (Object)(object)value != (Object)null)
			{
				Object.Destroy((Object)(object)value);
			}
			scanNodesByPlayerIndex.Remove(num);
			ulong playerSteamId = player.playerSteamId;
			bool flag = false;
			PlayerScanData value2 = null;
			string text2 = player.playerSteamId.ToString();
			if (!scanNodeData.TryGetValue(text2, out value2))
			{
				string text3 = player.playerUsername?.Trim() ?? string.Empty;
				MysteryDice.ExtendedLogging("[ScanNode] No SteamID match for " + text2 + ". Trying username key '" + text3 + "'. Known keys: " + string.Join(", ", scanNodeData.Keys), (LogLevel)16);
				if (scanNodeData.TryGetValue(text3, out var value3))
				{
					value2 = value3;
				}
			}
			if (value2 != null)
			{
				text = value2.top;
				subText = value2.bottom;
				flag = value2.isRainbow;
				ColorUtility.TryParseHtmlString(value2.bg, ref black);
				ColorUtility.TryParseHtmlString(value2.text, ref black2);
				MysteryDice.ExtendedLogging($"[ScanNode] Using data for player '{player.playerUsername}' (steamID {player.playerSteamId}).", (LogLevel)16);
			}
			else
			{
				MysteryDice.ExtendedLogging("[ScanNode] No scan data found for steamID=" + text2 + " or username='" + player.playerUsername + "'.", (LogLevel)16);
				text = "";
			}
			GameObject playerNodeController = MysteryDice.PlayerNodeController;
			if (Object.op_Implicit((Object)(object)playerNodeController) && !(text == "") && (!player.IsLocalPlayer() || MysteryDice.showOwnScanNode.Value))
			{
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(0f, 2.5f, 0f);
				GameObject val2 = Object.Instantiate<GameObject>(playerNodeController, ((Component)player).transform.position + val, Quaternion.identity);
				PlayerTracker playerTracker = val2.AddComponent<PlayerTracker>();
				playerTracker.init(player, val, player.playerSteamId);
				ForceScanColorOnItem componentInChildren = val2.GetComponentInChildren<ForceScanColorOnItem>();
				componentInChildren.borderColor = black;
				componentInChildren.textColor = black2;
				ScanNodeProperties componentInChildren2 = val2.GetComponentInChildren<ScanNodeProperties>();
				componentInChildren2.headerText = text;
				componentInChildren2.subText = subText;
				if (flag)
				{
					val2.AddComponent<RainbowScanNode>();
				}
				scanNodesByPlayerIndex[num] = val2;
				playerScanNodes.Add(val2);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddControllerServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1906074443u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1906074443u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AddControllerClientRPC(playerID);
				}
			}
		}

		[ClientRpc]
		public void AddControllerClientRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2717902209u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2717902209u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					InstantiateSpecialPrefabForPlayer(StartOfRound.Instance.allPlayerScripts[playerID]);
				}
			}
		}

		private void OnNewRoundStart()
		{
			if (MysteryDice.CodeRebirthPresent)
			{
				CodeRebirthCheckConfigs.listAll();
			}
			_entrancePoints = Object.FindObjectsByType<EntranceTeleport>((FindObjectsSortMode)1);
			EntranceTeleport[] entrancePoints = _entrancePoints;
			foreach (EntranceTeleport val in entrancePoints)
			{
				if (!val.FindExitPoint())
				{
					MysteryDice.CustomLogger.LogError((object)"Something went wrong in the generation of the fire exits! (ignorable if EntranceTeleportOptimisation is installed)");
				}
			}
			((MonoBehaviour)this).StartCoroutine(LoadScanDataFromURL("https://raw.githubusercontent.com/slayer6409/Emergency-Dice-Updated/refs/heads/master/docs/PlayerScanNodes.json?ver=" + Random.Range(0, 10000000), DefaultFallbackStuff));
			forceUpdatePlayers();
			((MonoBehaviour)this).StartCoroutine(ManyAds.LoadRemoteTextLists());
		}

		public IEnumerator SyncRequest()
		{
			while (!((Component)GameNetworkManager.Instance).GetComponent<NetworkManager>().IsConnectedClient)
			{
				yield return (object)new WaitForSeconds(0.5f);
			}
			while ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null)
			{
				yield return (object)new WaitForSeconds(0.5f);
			}
			RequestEffectConfigServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
			RequestConfigSyncServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public override void OnDestroy()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)("Dice: [DestroyDebugger] " + ((Object)((Component)this).gameObject).name + " was destroyed!\nEither you left the game or something bad happened!\nStackTrace:\n" + new StackTrace()));
			}
			((NetworkBehaviour)this).OnDestroy();
		}

		public override void OnNetworkDespawn()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)("Dice: [Network] " + ((Object)((Component)this).gameObject).name + " is despawning!\nEither you left the game or something bad happened! StackTrace:\n" + new StackTrace()));
			}
			StartOfRoundPatch.ResetSettingsShared();
			((NetworkBehaviour)this).OnNetworkDespawn();
		}

		private void FixedUpdate()
		{
			UpdateMineTimers();
			if (Armageddon.IsEnabled)
			{
				Armageddon.BoomTimer();
			}
			HyperShake.FixedUpdate();
			LeverShake.FixedUpdate();
			Drunk.FixedUpdate();
			Lizard.FixedUpdate();
			ChangePlaces.FixedUpdate();
			TwitchSpawner();
			if (SelectEffect.ReviveOpen && (Object)(object)SelectEffect.EffectMenu == (Object)null)
			{
				SelectEffect.ReviveOpen = false;
			}
		}

		private void LateUpdate()
		{
			if (IHearDeadPeople.isSixthSensed)
			{
				IHearDeadPeople.Update();
			}
			ModifyPitch.PitchFluctuate();
		}

		private void Update()
		{
			RebelCoilheads();
			AlarmCurse.TimerUpdate();
		}

		public void TwitchSpawner()
		{
			if ((Object)(object)StartOfRound.Instance != (Object)null && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
			{
				twitchCanRoll = true;
			}
			else
			{
				twitchCanRoll = false;
			}
			if (StartOfRound.Instance.currentLevel.PlanetName == "71 Gordion")
			{
				twitchCanRoll = false;
			}
			if (StartOfRound.Instance.currentLevel.PlanetName == "98 Galetry")
			{
				twitchCanRoll = false;
			}
			if (StartOfRound.Instance.currentLevel.sceneName == "Oxyde")
			{
				twitchCanRoll = false;
			}
			if (((NetworkBehaviour)this).IsServer && twitchCanRoll && spawnQueue.Count > 0)
			{
				ProcessSpawnQueue();
			}
		}

		public int CheckScaling()
		{
			Terminal val = Object.FindFirstObjectByType<Terminal>();
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			int valueOfAllScrap = StartOfRound.Instance.GetValueOfAllScrap(true, false);
			int daysPlayersSurvivedInARow = StartOfRound.Instance.daysPlayersSurvivedInARow;
			int daysSpent = StartOfRound.Instance.gameStats.daysSpent;
			switch (MysteryDice.brutalScaleType.Value)
			{
			case 0:
				return (int)Scale(daysSpent, 0.0, 50.0, MysteryDice.brutalStartingScale.Value, MysteryDice.brutalMaxScale.Value);
			case 1:
				return (int)Scale(valueOfAllScrap, 0.0, 2500.0, MysteryDice.brutalStartingScale.Value, MysteryDice.brutalMaxScale.Value);
			case 2:
				return (int)Scale(daysPlayersSurvivedInARow, 0.0, 15.0, MysteryDice.brutalStartingScale.Value, MysteryDice.brutalMaxScale.Value);
			case 3:
			{
				double num = (double)daysSpent / 50.0;
				double num2 = (double)valueOfAllScrap / 2500.0;
				double num3 = (num + num2) / 2.0;
				double num4 = (double)MysteryDice.brutalStartingScale.Value + num3 * (double)(MysteryDice.brutalMaxScale.Value - MysteryDice.brutalStartingScale.Value);
				return (int)num4;
			}
			case 4:
				return MysteryDice.brutalStartingScale.Value;
			default:
				return 0;
			}
		}

		public static double Scale(double x, double minInput, double maxInput, double minOutput, double maxOutput)
		{
			return minOutput + (x - minInput) * (maxOutput - minOutput) / (maxInput - minInput);
		}

		private void ProcessSpawnQueue()
		{
			int num = 0;
			while (spawnQueue.Count > 0 && twitchCanRoll && num < maxSpawnsPerFrame)
			{
				var (effect, who) = spawnQueue.Dequeue();
				((MonoBehaviour)this).StartCoroutine(RollEffects(effect, who));
				num++;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void LogEffectsToOwnerServerRPC(string playerName, string effectName, int roll)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_014a: 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_00cc: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2696892243u, val2, (RpcDelivery)0);
				bool flag = playerName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(playerName, false);
				}
				bool flag2 = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				BytePacker.WriteValueBitPacked(val, roll);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2696892243u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			MysteryDice.chatDebug result = MysteryDice.chatDebug.None;
			Enum.TryParse<MysteryDice.chatDebug>(MysteryDice.debugChat.Value, out result);
			if (MysteryDice.debugDice.Value)
			{
				MysteryDice.CustomLogger.LogInfo((object)$"[Debug] {playerName} rolled a {roll}: {effectName}");
			}
			if (playerName == "Brutal" && MysteryDice.BrutalChat.Value)
			{
				LogEffectsToEveryoneClientRPC(playerName, effectName, roll);
			}
			else if (!(playerName == "Brutal") || StartOfRound.Instance.allPlayerScripts.Any((PlayerControllerB x) => x.playerUsername == "Brutal"))
			{
				if (result == MysteryDice.chatDebug.Host)
				{
					LogEffectsToHostClientRPC(playerName, effectName, roll);
				}
				if (result == MysteryDice.chatDebug.Everyone)
				{
					LogEffectsToEveryoneClientRPC(playerName, effectName, roll);
				}
				if (result == MysteryDice.chatDebug.None)
				{
					LogEffectsToSlayerClientRPC(playerName, effectName, roll);
				}
			}
		}

		[ClientRpc]
		public void LogEffectsToHostClientRPC(string playerName, string effectName, int roll)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_014a: 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_00cc: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1737623636u, val2, (RpcDelivery)0);
				bool flag = playerName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(playerName, false);
				}
				bool flag2 = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				BytePacker.WriteValueBitPacked(val, roll);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1737623636u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsHost || GameNetworkManager.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID)
				{
					Misc.ChatWrite($"{playerName} rolled a {roll}: {effectName}");
				}
			}
		}

		[ClientRpc]
		public void LogEffectsToSlayerClientRPC(string playerName, string effectName, int roll)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_014a: 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_00cc: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1307310058u, val2, (RpcDelivery)0);
				bool flag = playerName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(playerName, false);
				}
				bool flag2 = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				BytePacker.WriteValueBitPacked(val, roll);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1307310058u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (GameNetworkManager.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID)
				{
					Misc.ChatWrite($"{playerName} rolled a {roll}: {effectName}");
				}
			}
		}

		[ClientRpc]
		public void LogEffectsToEveryoneClientRPC(string playerName, string effectName, int roll)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_014a: 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_00cc: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1822397394u, val2, (RpcDelivery)0);
				bool flag = playerName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(playerName, false);
				}
				bool flag2 = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				BytePacker.WriteValueBitPacked(val, roll);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1822397394u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				Misc.ChatWrite($"{playerName} rolled a {roll}: {effectName}");
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestEffectConfigServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1360560965u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1360560965u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			foreach (IEffect allowedEffect in DieBehaviour.AllowedEffects)
			{
				SendConfigClientRPC(playerID, allowedEffect.Name);
			}
		}

		[ClientRpc]
		public void SendConfigClientRPC(int playerID, string effectName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4142878533u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				bool flag = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 4142878533u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			string effectName2 = effectName;
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerID);
			if ((Object)(object)playerByUserID == (Object)null || !Misc.IsPlayerReal(playerByUserID))
			{
				MysteryDice.CustomLogger.LogError((object)$"Player with ID {playerID} is either null or not real.");
			}
			else if (!((NetworkBehaviour)this).IsServer && Misc.isPlayerLocal(playerID))
			{
				DieBehaviour.AllowedEffects.Add(DieBehaviour.AllEffects.Where((IEffect x) => x.Name == effectName2).First());
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestConfigSyncServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(79093998u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 79093998u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			List<ConfigEntryBase> listConfigs = MysteryDice.GetListConfigs();
			foreach (ConfigEntryBase item in listConfigs)
			{
				string key = item.Definition.Key;
				string section = item.Definition.Section;
				int typeCode = (int)Type.GetTypeCode(item.SettingType);
				if (item.BoxedValue is int ival)
				{
					SendConfigsClientRPC(playerID, key, section, typeCode, ival);
				}
				else if (item.BoxedValue is bool bval)
				{
					SendConfigsClientRPC(playerID, key, section, typeCode, 0, bval);
				}
				else if (item.BoxedValue is string sval)
				{
					SendConfigsClientRPC(playerID, key, section, typeCode, 0, bval: false, sval);
				}
				else if (item.BoxedValue is Enum obj)
				{
					SendConfigsClientRPC(playerID, key, section, typeCode, 0, bval: false, "", obj.ToString());
				}
			}
		}

		[ClientRpc]
		public void SendConfigsClientRPC(int playerID, string key, string section, int type, int ival = 0, bool bval = false, string sval = "", string enumVal = "")
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_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_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_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_0146: 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_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_01b6: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3630596093u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				bool flag = key != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(key, false);
				}
				bool flag2 = section != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(section, false);
				}
				BytePacker.WriteValueBitPacked(val, type);
				BytePacker.WriteValueBitPacked(val, ival);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref bval, default(ForPrimitives));
				bool flag3 = sval != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(sval, false);
				}
				bool flag4 = enumVal != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag4, default(ForPrimitives));
				if (flag4)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(enumVal, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3630596093u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsServer || !Misc.isPlayerLocal(playerID))
			{
				return;
			}
			try
			{
				List<ConfigEntryBase> listConfigs = MysteryDice.GetListConfigs();
				foreach (ConfigEntryBase item in listConfigs)
				{
					if (!(item.Definition.Key == key) || !(item.Definition.Section == section))
					{
						continue;
					}
					switch ((TypeCode)type)
					{
					case TypeCode.Int32:
						item.BoxedValue = ival;
						break;
					case TypeCode.Boolean:
						item.BoxedValue = bval;
						break;
					case TypeCode.String:
						item.BoxedValue = sval;
						break;
					case TypeCode.Object:
						if (item.SettingType.IsEnum)
						{
							item.BoxedValue = Enum.Parse(item.SettingType, enumVal);
						}
						break;
					}
				}
			}
			catch
			{
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestSyncCursedServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3353804004u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3353804004u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SyncCursedPlayersClientRpc(cursedPeople.ToArray());
				}
			}
		}

		[ClientRpc]
		public void SyncCursedPlayersClientRpc(ulong[] cursedIds)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1002459835u, val2, (RpcDelivery)0);
				bool flag = cursedIds != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(cursedIds, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1002459835u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsHost)
			{
				return;
			}
			cursedPeople.Clear();
			for (int i = 0; i < cursedIds.Length; i++)
			{
				ulong item = cursedIds[i];
				cursedPeople.Add(item);
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Added " + item + " to cursed players."));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void killPlayerServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(324328356u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 324328356u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					killPlayerClientRPC(playerID);
				}
			}
		}

		[ClientRpc]
		public void killPlayerClientRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_00ea: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(515572243u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 515572243u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					StartOfRound.Instance.allPlayerScripts[playerID].KillPlayer(Vector3.zero, true, (CauseOfDeath)1, 0, default(Vector3), false);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FixPlayerServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(275668481u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 275668481u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Vector3 serverPlayerPosition = StartOfRound.Instance.allPlayerScripts[playerID].serverPlayerPosition;
					killPlayerClientRPC(playerID);
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(doFix(serverPlayerPosition, playerID));
				}
			}
		}

		private IEnumerator doFix(Vector3 pos, int playerID)
		{
			//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)
			yield return (object)new WaitForSeconds(0.45f);
			RevivePlayerServerRpc(playerID, pos);
		}

		[ServerRpc(RequireOwnership = false)]
		public void MoveTrapServerRpc(int getInstanceID, Vector3 targetPosition, bool isInside)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009d: 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_00f6: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4005833429u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, getInstanceID);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref targetPosition);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref isInside, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 4005833429u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				int getInstanceID2 = getInstanceID;
				SmartAgentNavigator smartAgentNavigator = PlayerControllerBPatch.smartAgentNavigators.Find((SmartAgentNavigator x) => ((Object)x).GetInstanceID() == getInstanceID2);
				if (!((Object)(object)smartAgentNavigator == (Object)null))
				{
					smartAgentNavigator.DoPathingToDestination(targetPosition);
				}
			}
		}

		public IEnumerator RollEffects(IEffect effect, string who)
		{
			yield return (object)new WaitForSeconds(Random.Range(5f, 12f));
			if (!twitchCanRoll)
			{
				spawnQueue.Enqueue((effect, who));
				yield break;
			}
			LogEffectsToOwnerServerRPC(who, effect.Name, 0);
			rollEffectRandomPlayerServerRPC(effect.Name);
		}

		[ServerRpc(RequireOwnership = false)]
		public void rollEffectRandomPlayerServerRPC(string effect)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3424035373u, val2, (RpcDelivery)0);
				bool flag = effect != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effect, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3424035373u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB randomPlayer = Misc.GetRandomPlayer();
				ProcessRollEffectClientRPC(effect, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomPlayer));
			}
		}

		[ClientRpc]
		public void ProcessRollEffectClientRPC(string effect, int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2557683131u, val2, (RpcDelivery)0);
				bool flag = effect != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effect, false);
				}
				BytePacker.WriteValueBitPacked(val, playerID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2557683131u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			string effect2 = effect;
			if (Misc.isPlayerLocal(playerID))
			{
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)"Rolling from queue");
				}
				DieBehaviour.AllowedEffects.Find((IEffect x) => x.Name == effect2).Use();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void QueueRandomDiceEffectServerRPC(string who)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(26955910u, val2, (RpcDelivery)0);
				bool flag = who != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(who, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 26955910u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				spawnQueue.Enqueue((DieBehaviour.AllowedEffects[Random.Range(0, DieBehaviour.AllowedEffects.Count)], who));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void QueueSpecificDiceEffectServerRPC(string who, string effectName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_013d: 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_00cc: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1559418665u, val2, (RpcDelivery)0);
				bool flag = who != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(who, false);
				}
				bool flag2 = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1559418665u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string effectName2 = effectName;
				spawnQueue.Enqueue((DieBehaviour.AllowedEffects.Find((IEffect x) => x.Name == effectName2), who));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void QueueSelectTypeServerRPC(EffectType effectType, string who)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_00a3: 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_011a: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(775413581u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<EffectType>(ref effectType, default(ForEnums));
				bool flag = who != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(who, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 775413581u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				List<IEffect> list = new List<IEffect>();
				switch (effectType)
				{
				case EffectType.Awful:
					list.AddRange(DieBehaviour.AwfulEffects);
					break;
				case EffectType.Bad:
					list.AddRange(DieBehaviour.BadEffects);
					break;
				case EffectType.Good:
					list.AddRange(DieBehaviour.GoodEffects);
					break;
				case EffectType.Great:
					list.AddRange(DieBehaviour.GreatEffects);
					break;
				case EffectType.Mixed:
					list.AddRange(DieBehaviour.MixedEffects);
					break;
				}
				spawnQueue.Enqueue((list[Random.Range(0, list.Count)], who));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void NemosplosionServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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_012b: 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_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_015d: 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_0174: 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_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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2898041828u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2898041828u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			int num = 12;
			int num2 = 2;
			SpawnableEnemyWithRarity enemyByName = Misc.getEnemyByName("Nemo");
			RoundManager instance = RoundManager.Instance;
			if (enemyByName != null)
			{
				PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
				List<EnemyAI> list = new List<EnemyAI>();
				Vector3 val3 = default(Vector3);
				for (int i = 0; i < num; i++)
				{
					float num3 = (float)i * MathF.PI * 2f / (float)num;
					((Vector3)(ref val3))..ctor(Mathf.Cos(num3) * (float)num2, ((Component)randomAlivePlayer).transform.position.y + 0.25f, Mathf.Sin(num3) * (float)num2);
					val3 += ((Component)randomAlivePlayer).transform.position;
					Vector3 val4 = ((Component)randomAlivePlayer).transform.position - val3;
					Quaternion val5 = Quaternion.LookRotation(val4);
					GameObject val6 = Object.Instantiate<GameObject>(enemyByName.enemyType.enemyPrefab, val3, val5);
					NetworkObject componentInChildren = val6.GetComponentInChildren<NetworkObject>();
					componentInChildren.Spawn(true);
					EnemyAI component = val6.GetComponent<EnemyAI>();
					RoundManager.Instance.SpawnedEnemies.Add(component);
					list.Add(component);
				}
				((MonoBehaviour)this).StartCoroutine(ExplodeNemos(list, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomAlivePlayer)));
			}
		}

		public IEnumerator ExplodeNemos(List<EnemyAI> enemies, int target)
		{
			yield return (object)new WaitForSeconds(3f);
			StartOfRound.Instance.allowLocalPlayerDeath = false;
			foreach (EnemyAI enemy in enemies)
			{
				Landmine.SpawnExplosion(((Component)enemy).transform.position, true, 1f, 2f, 50, 0f, (GameObject)null, false);
				enemy.KillEnemy(false);
			}
			removeKillServerRPC(target, 7);
		}

		[ServerRpc(RequireOwnership = false)]
		public void UnkillableServerRpc(int target)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2543568230u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, target);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2543568230u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					removeKillClientRPC(target, 30);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void removeKillServerRPC(int target, int time)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3338645896u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, target);
					BytePacker.WriteValueBitPacked(val, time);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3338645896u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					removeKillClientRPC(target, time);
				}
			}
		}

		[ClientRpc]
		public void removeKillClientRPC(int target, int time)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2450559096u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, target);
				BytePacker.WriteValueBitPacked(val, time);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2450559096u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (Misc.isPlayerLocal(target))
				{
					((MonoBehaviour)Instance).StartCoroutine(DoNoKill(time));
				}
			}
		}

		public IEnumerator DoNoKill(int time)
		{
			StartOfRound.Instance.allowLocalPlayerDeath = false;
			yield return (object)new WaitForSeconds((float)time);
			StartOfRound.Instance.allowLocalPlayerDeath = true;
		}

		[ServerRpc(RequireOwnership = false)]
		public void AdServerRPC(bool item, string name, string top, string bottom)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_00a3: 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_0196: 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_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_0151: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1037540588u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref item, default(ForPrimitives));
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				bool flag2 = top != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(top, false);
				}
				bool flag3 = bottom != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(bottom, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1037540588u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AdClientRPC(item, name, top, bottom);
			}
		}

		[ClientRpc]
		public void AdClientRPC(bool item, string name, string top, string bottom)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_00a3: 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_0196: 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_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_0151: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1632183355u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref item, default(ForPrimitives));
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				bool flag2 = top != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(top, false);
				}
				bool flag3 = bottom != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(bottom, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1632183355u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ManyAds.QueueAd(item, name, top, bottom);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TriggerManyAdsServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4103428810u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 4103428810u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				for (int i = 0; i < 4; i++)
				{
					ManyAds.showRandomAd();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TriggerSelectAdsServerRpc(int num)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(433094646u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, num);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 433094646u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				for (int i = 0; i < num; i++)
				{
					ManyAds.showRandomAd();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RandomAdItemServerRpc(string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1369477639u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1369477639u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ManyAds.QueueAd(isTool: true, name, ManyAds.getTopText(), ManyAds.getBottomText());
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestEmotesInRadiusServerRpc(Vector3 center, float radius)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_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_00a4: 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_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_0151: 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_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_017e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1996097052u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref center);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref radius, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1996097052u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				if (!((Object)(object)val3 == (Object)null) && !val3.isPlayerDead && val3.isPlayerControlled && Vector3.Distance(((Component)val3).transform.position, center) <= radius)
				{
					PerformRandomEmoteClientRpc(val3.playerClientId, new ClientRpcParams
					{
						Send = new ClientRpcSendParams
						{
							TargetClientIds = new ulong[1] { val3.playerClientId }
						}
					});
				}
			}
		}

		[ClientRpc]
		private void PerformRandomEmoteClientRpc(ulong forClientId, ClientRpcParams rpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2209572773u, rpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, forClientId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2209572773u, rpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.LocalClientId == forClientId && Chainloader.PluginInfos.ContainsKey("FlipMods.TooManyEmotes"))
				{
					PerformRandomEmote.PerformEmote();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void setHealthServerRPC(int player, int health)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1413525009u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					BytePacker.WriteValueBitPacked(val, health);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1413525009u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					setHealthClientRPC(player, health);
				}
			}
		}

		[ClientRpc]
		public void setHealthClientRPC(int playerID, int health)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(405187854u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				BytePacker.WriteValueBitPacked(val, health);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 405187854u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerID];
				if (!val3.isPlayerDead && !((Object)(object)val3 != (Object)(object)StartOfRound.Instance.localPlayerController))
				{
					val3.health = health;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnSurroundedServerRPC(string enemyName, int amount = 10, int radius = 3, bool doSize = false, Vector3 size = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0141: 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_00bc: 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_00fc: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01b3: 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_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01ea: 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_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_0202: 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_0206: 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_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: 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_028e: 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_02cf: 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_02d9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4264730339u, val2, (RpcDelivery)0);
				bool flag = enemyName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(enemyName, false);
				}
				BytePacker.WriteValueBitPacked(val, amount);
				BytePacker.WriteValueBitPacked(val, radius);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref doSize, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref size);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 4264730339u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			SpawnableEnemyWithRarity enemyByName = Misc.getEnemyByName(enemyName);
			RoundManager instance = RoundManager.Instance;
			if (enemyByName == null)
			{
				return;
			}
			PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
			RaycastHit val7 = default(RaycastHit);
			for (int i = 0; i < amount; i++)
			{
				float num = (float)i * MathF.PI * 2f / (float)amount;
				Vector3 val3 = new Vector3(Mathf.Cos(num), 0f, Mathf.Sin(num)) * (float)radius;
				Vector3 val4 = ((Component)randomAlivePlayer).transform.position + val3 + new Vector3(0f, 0.25f, 0f);
				Quaternion val5 = Quaternion.LookRotation(((Component)randomAlivePlayer).transform.position - val4);
				Vector3 val6 = val4 + Vector3.up * 2f;
				if (!Physics.Raycast(val6, Vector3.down, ref val7, 10f, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
				{
					continue;
				}
				val4 = ((RaycastHit)(ref val7)).point;
				if (!(val4.y > ((Component)randomAlivePlayer).transform.position.y + 10f) && !(val4.y < ((Component)randomAlivePlayer).transform.position.y - 5f))
				{
					GameObject val8 = Object.Instantiate<GameObject>(enemyByName.enemyType.enemyPrefab, val4, val5);
					NetworkObject componentInChildren = val8.GetComponentInChildren<NetworkObject>();
					componentInChildren.Spawn(true);
					instance.SpawnedEnemies.Add(val8.GetComponent<EnemyAI>());
					if (doSize)
					{
						setSizeClientRPC(componentInChildren.NetworkObjectId, size);
					}
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnSurroundedSelectServerRPC(string enemyName, int playerInt, int amount = 10, int radius = 3, bool doSize = false, Vector3 size = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_014e: 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_00bc: 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_00e8: 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_01ab: 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_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_01c7: 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_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_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_01f4: 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_01fe: 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_0202: 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_0216: 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_021a: 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)
			//IL_024e: 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_026d: 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_02a2: 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_02e3: 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_02ed: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2614339007u, val2, (RpcDelivery)0);
				bool flag = enemyName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(enemyName, false);
				}
				BytePacker.WriteValueBitPacked(val, playerInt);
				BytePacker.WriteValueBitPacked(val, amount);
				BytePacker.WriteValueBitPacked(val, radius);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref doSize, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref size);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2614339007u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			SpawnableEnemyWithRarity enemyByName = Misc.getEnemyByName(enemyName);
			RoundManager instance = RoundManager.Instance;
			if (enemyByName == null)
			{
				return;
			}
			PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerInt];
			RaycastHit val8 = default(RaycastHit);
			for (int i = 0; i < amount; i++)
			{
				float num = (float)i * MathF.PI * 2f / (float)amount;
				Vector3 val4 = new Vector3(Mathf.Cos(num), 0f, Mathf.Sin(num)) * (float)radius;
				Vector3 val5 = ((Component)val3).transform.position + val4 + new Vector3(0f, 0.25f, 0f);
				Quaternion val6 = Quaternion.LookRotation(((Component)val3).transform.position - val5);
				Vector3 val7 = val5 + Vector3.up * 2f;
				if (!Physics.Raycast(val7, Vector3.down, ref val8, 10f, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
				{
					continue;
				}
				val5 = ((RaycastHit)(ref val8)).point;
				if (!(val5.y > ((Component)val3).transform.position.y + 10f) && !(val5.y < ((Component)val3).transform.position.y - 5f))
				{
					GameObject val9 = Object.Instantiate<GameObject>(enemyByName.enemyType.enemyPrefab, val5, val6);
					NetworkObject componentInChildren = val9.GetComponentInChildren<NetworkObject>();
					componentInChildren.Spawn(true);
					instance.SpawnedEnemies.Add(val9.GetComponent<EnemyAI>());
					if (doSize)
					{
						setSizeClientRPC(componentInChildren.NetworkObjectId, size);
					}
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnSurroundedTrapServerRPC(string trapName, int amount = 10, int radius = 3, bool doSize = false, Vector3 size = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0141: 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_00bc: 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_00fc: 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_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_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_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_01cf: 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_01d3: 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_0221: 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_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_0219: 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_0238: 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_0247: 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_02a2: 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_0287: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2456088190u, val2, (RpcDelivery)0);
				bool flag = trapName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(trapName, false);
				}
				BytePacker.WriteValueBitPacked(val, amount);
				BytePacker.WriteValueBitPacked(val, radius);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref doSize, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref size);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2456088190u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			trap trap2 = DynamicTrapEffect.getTrap(trapName);
			RoundManager instance = RoundManager.Instance;
			if (trap2 == null)
			{
				return;
			}
			PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
			Vector3 val3 = default(Vector3);
			RaycastHit val7 = default(RaycastHit);
			for (int i = 0; i < amount; i++)
			{
				float num = (float)i * MathF.PI * 2f / (float)amount;
				((Vector3)(ref val3))..ctor(Mathf.Cos(num) * (float)radius, 0f, Mathf.Sin(num) * (float)radius);
				Vector3 val4 = ((Component)randomAlivePlayer).transform.position + val3;
				Vector3 val5 = val4 + Vector3.up * 10f;
				Vector3 val6 = ((!Physics.Raycast(val5, Vector3.down, ref val7, 20f, LayerMask.GetMask(new string[1] { "Default" }))) ? val4 : (((RaycastHit)(ref val7)).point + Vector3.up * 0.01f));
				Vector3 val8 = ((Component)randomAlivePlayer).transform.position - val6;
				Quaternion val9 = Quaternion.LookRotation(val8);
				GameObject val10 = Object.Instantiate<GameObject>(trap2.prefab, val6, val9);
				NetworkObject componentInChildren = val10.GetComponentInChildren<NetworkObject>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.Spawn(true);
				}
				if (doSize)
				{
					setSizeClientRPC(componentInChildren.NetworkObjectId, size);
				}
				SceneManager.MoveGameObjectToScene(val10, RoundManager.Instance.mapPropsContainer.scene);
			}
		}

		[ClientRpc]
		public void setSizeClientRPC(ulong objectId, Vector3 size, Quaternion rotation = default(Quaternion))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00e8: 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_0126: 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)
			//IL_014a: 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_0166: 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_0176: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1227566611u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectId);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref size);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref rotation);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1227566611u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectId, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				Vector3 localScale = default(Vector3);
				((Vector3)(ref localScale))..ctor(gameObject.transform.localScale.x * size.x, gameObject.transform.localScale.y * size.y, gameObject.transform.localScale.z * size.z);
				gameObject.transform.localScale = localScale;
				if (rotation != default(Quaternion))
				{
					gameObject.transform.localRotation = rotation;
				}
			}
		}

		[ClientRpc]
		public void MatchSizeClientRPC(ulong objectSource, ulong objectTarget, bool preserveRatio = true)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0097: 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_00b1: 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_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_01a0: 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_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_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_0251: 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_0260: 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_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: 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_0296: 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_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: 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_020b: 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_0240: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2881472247u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectSource);
				BytePacker.WriteValueBitPacked(val, objectTarget);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref preserveRatio, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2881472247u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectSource, out var value) || !NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectTarget, out var value2))
			{
				return;
			}
			GameObject gameObject = ((Component)value).gameObject;
			GameObject gameObject2 = ((Component)value2).gameObject;
			Renderer componentInChildren = gameObject.GetComponentInChildren<Renderer>();
			Renderer componentInChildren2 = gameObject2.GetComponentInChildren<Renderer>();
			if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren2 == (Object)null)
			{
				MysteryDice.CustomLogger.LogWarning((object)"One of the objects has no Renderer.");
				return;
			}
			Bounds bounds = componentInChildren.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			bounds = componentInChildren2.bounds;
			Vector3 size2 = ((Bounds)(ref bounds)).size;
			if (preserveRatio)
			{
				float num = Mathf.Max(new float[3] { size.x, size.y, size.z });
				float num2 = Mathf.Max(new float[3] { size2.x, size2.y, size2.z });
				if (num != 0f)
				{
					float num3 = num2 / num;
					Transform transform = gameObject.transform;
					transform.localScale *= num3;
				}
			}
			else
			{
				Vector3 val3 = default(Vector3);
				((Vector3)(ref val3))..ctor(size2.x / size.x, size2.y / size.y, size2.z / size.z);
				gameObject.transform.localScale = Vector3.Scale(gameObject.transform.localScale, val3);
			}
		}

		[ClientRpc]
		public void setDiceSizeClientRPC(ulong diceNetObj, Vector3 size = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00db: 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_0122: 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_0139: 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_0150: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1580401083u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, diceNetObj);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref size);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1580401083u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(diceNetObj, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					GameObject diceModel = gameObject.GetComponent<DieBehaviour>().DiceModel;
					Vector3 localScale = default(Vector3);
					((Vector3)(ref localScale))..ctor(diceModel.transform.localScale.x * size.x, diceModel.transform.localScale.y * size.y, diceModel.transform.localScale.z * size.z);
					diceModel.transform.localScale = localScale;
				}
			}
		}

		[ClientRpc]
		public void removeShadowsClientRPC(ulong objectId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_011f: Expected O, but got Unknown
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2393095572u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2393095572u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectId, out var value))
			{
				return;
			}
			GameObject gameObject = ((Component)value).gameObject;
			Renderer component = gameObject.GetComponent<Renderer>();
			foreach (GameObject item in gameObject.transform)
			{
				GameObject val3 = item;
				Renderer component2 = val3.GetComponent<Renderer>();
				if ((Object)(object)component2 != (Object)null)
				{
					component.shadowCastingMode = (ShadowCastingMode)0;
				}
				if ((Object)(object)component2 != (Object)null)
				{
					component.receiveShadows = false;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void spawnFlingerServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2164475308u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2164475308u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Flinger.spawnHorseshoe(userID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void setHorseStuffServerRPC(ulong netObject, int super = 0)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1091680114u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, netObject);
					BytePacker.WriteValueBitPacked(val, super);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1091680114u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					setHorseStuffClientRPC(netObject, super, Random.Range(-20, 20), Random.Range(-40, 40), Random.Range(-100, 100));
				}
			}
		}

		[ClientRpc]
		public void setHorseStuffClientRPC(ulong netObject, int super, int a, int b, int c)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_008b: 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_00a5: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1137837317u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, netObject);
				BytePacker.WriteValueBitPacked(val, super);
				BytePacker.WriteValueBitPacked(val, a);
				BytePacker.WriteValueBitPacked(val, b);
				BytePacker.WriteValueBitPacked(val, c);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1137837317u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			try
			{
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(netObject, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					switch (super)
					{
					case 0:
						Flinger.horseStuff(gameObject);
						break;
					case 1:
						SuperFlinger.horseStuff(gameObject, a, b, c);
						break;
					case 2:
						Horseshootnt.horseStuff(gameObject);
						break;
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogWarning((object)("Probably not an error, but: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void DelayedReactionServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1535208873u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1535208873u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(delayed(userID));
				}
			}
		}

		private IEnumerator delayed(int userID)
		{
			Random.Range(15, 45);
			yield return (object)new WaitForSeconds((float)Random.Range(15, 45));
			DelayedReactionClientRPC(userID);
		}

		[ClientRpc]
		public void DelayedReactionClientRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3851315013u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3851315013u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					QueueRandomDiceEffectServerRPC(Misc.GetPlayerByUserID(userID).playerUsername);
					Misc.SafeTipMessage(":P", "Almost There...");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AlarmServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1097447221u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1097447221u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AlarmClientRPC(userID);
				}
			}
		}

		[ClientRpc]
		public void AlarmClientRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3450213494u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3450213494u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (Misc.isPlayerLocal(userID))
				{
					AlarmCurse.setAlarm();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ShowAdMenuServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_00ed: 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_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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3393414643u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3393414643u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[userID];
					ClientRpcParams rpcParams = new ClientRpcParams
					{
						Send = new ClientRpcSendParams
						{
							TargetClientIds = new ulong[1] { val3.playerClientId }
						}
					};
					ShowAdMenuClientRPC(rpcParams);
				}
			}
		}

		[ClientRpc]
		public void ShowAdMenuClientRPC(ClientRpcParams rpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2183580584u, rpcParams, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2183580584u, rpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					DebugMenuStuff.ShowSelectEffectMenu(isAdMenu: true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FreeCruiserServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1121024086u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1121024086u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SpawnCruiser.Spawn(temporary: true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void DeleteThingServerRPC(NetworkObjectReference scrapNetObject)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(866465074u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref scrapNetObject, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 866465074u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				NetworkObject val3 = default(NetworkObject);
				if (((NetworkObjectReference)(ref scrapNetObject)).TryGet(ref val3, (NetworkManager)null))
				{
					val3.Despawn(true);
				}
			}
		}

		public void UpdateMineTimers()
		{
			if (ExplosionTimer >= 0f)
			{
				ExplosionTimer -= Time.fixedDeltaTime;
				if (ExplosionTimer < 0f)
				{
					DetonatePlayerClientRPC(PlayerIDToExplode);
				}
			}
		}

		public void StartDoomCountdown(int playerID)
		{
			PlayerIDToExplode = playerID;
			ExplosionTimer = Random.Range(TimerRange.x, TimerRange.y);
		}

		[ClientRpc]
		public void OnStartRoundClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1118192716u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1118192716u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					StartOfRoundPatch.StartGameOnClient();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void DetonateRandomPlayerServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1471895020u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1471895020u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (StartOfRound.Instance != null && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					List<PlayerControllerB> list = new List<PlayerControllerB>();
					list = getValidPlayers();
					PlayerControllerB value = list[Random.Range(0, list.Count)];
					StartDoomCountdown(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, value));
				}
			}
		}

		public List<PlayerControllerB> getValidPlayers()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (Misc.IsPlayerAliveAndControlled(val))
				{
					list.Add(val);
				}
			}
			return list;
		}

		[ServerRpc(RequireOwnership = false)]
		public void DoLizardServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1224495368u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1224495368u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (StartOfRound.Instance != null && !Lizard.isRunning)
				{
					Lizard.isRunning = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ConfusionPlayerServerRPC(bool stupidMode)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3864594486u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref stupidMode, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3864594486u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ConfusionPlayerClientRPC(stupidMode);
				}
			}
		}

		[ClientRpc]
		public void ConfusionPlayerClientRPC(bool stupidMode)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(361427529u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref stupidMode, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 361427529u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Confusion.isConfused = true;
			PlayerControllerB player = StartOfRound.Instance.localPlayerController;
			if (player.playerSteamId == 76561199094139351L)
			{
				return;
			}
			if ((Object)(object)((Component)player).gameObject.GetComponent<confusionPlayer>() != (Object)null)
			{
				((Component)player).gameObject.GetComponent<confusionPlayer>().stupidMode = stupidMode;
				return;
			}
			confusionPlayer confusionPlayer = ((Component)player).gameObject.AddComponent<confusionPlayer>();
			confusionPlayer.currentSuit = orderedSuits.Find((UnlockableSuit x) => x.suitID == player.currentSuitID);
			confusionPlayer.player = player;
			confusionPlayer.stupidMode = stupidMode;
		}

		[ServerRpc(RequireOwnership = false)]
		public void OopsPlayerServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(698961352u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 698961352u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
				if (allPlayerScripts.Length != 0)
				{
					int num = Random.Range(0, allPlayerScripts.Length);
					PlayerControllerB val3 = allPlayerScripts[num];
					int currentSuitID = val3.currentSuitID;
					MysteryDice.CustomLogger.LogInfo((object)$"Oops! Everyone is now wearing {val3.playerUsername}'s suit (ID {currentSuitID})");
					OopsPlayerClientRPC(currentSuitID);
				}
			}
		}

		[ClientRpc]
		public void OopsPlayerClientRPC(int suitID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2884546173u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, suitID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2884546173u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			int suitID2 = suitID;
			PlayerControllerB player = StartOfRound.Instance.localPlayerController;
			UnlockableSuit suitToSwitchTo = orderedSuits.Find((UnlockableSuit x) => x.suitID == suitID2);
			oopsController oopsController = ((Component)player).GetComponent<oopsController>();
			if ((Object)(object)oopsController == (Object)null)
			{
				oopsController = ((Component)player).gameObject.AddComponent<oopsController>();
				oopsController.currentSuit = orderedSuits.Find((UnlockableSuit x) => x.suitID == player.currentSuitID);
				oopsController.player = player;
			}
			oopsController.suitToSwitchTo = suitToSwitchTo;
			oopsController.switchSuit();
		}

		[ClientRpc]
		public void DetonatePlayerClientRPC(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3908042166u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, clientID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3908042166u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
			{
				PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[clientID];
				if (Misc.isPlayerLocal(clientID) && Misc.IsPlayerAliveAndControlled(val3))
				{
					MysteryDice.sounds.TryGetValue("MineTrigger", out var value);
					AudioSource.PlayClipAtPoint(value, ((Component)val3).transform.position);
					((MonoBehaviour)this).StartCoroutine(SpawnExplosionAfterSFX(((Component)val3).transform.position));
				}
			}
		}

		private IEnumerator SpawnExplosionAfterSFX(Vector3 position, int killrange = 1, int damageRange = 5, int nonLethalDamage = 50, int physicForce = 0)
		{
			//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)
			yield return (object)new WaitForSeconds(0.5f);
			Landmine.SpawnExplosion(position, true, (float)killrange, (float)damageRange, nonLethalDamage, (float)physicForce, (GameObject)null, false);
		}

		[ServerRpc(RequireOwnership = false)]
		public void ReviveAllPlayersServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3123714467u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3123714467u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance == (Object)null))
				{
					ReviveAllPlayersClientRpc();
				}
			}
		}

		[ClientRpc]
		public void ReviveAllPlayersClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(954997453u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 954997453u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!((Object)(object)StartOfRound.Instance == (Object)null))
			{
				PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
				StartOfRound.Instance.ReviveDeadPlayers();
				if ((Object)(object)localPlayerController == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
					HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
					localPlayerController.hinderedMultiplier = 1f;
					localPlayerController.isMovementHindered = 0;
					localPlayerController.sourcesCausingSinking = 0;
					((Component)localPlayerController.deadBody).gameObject.SetActive(false);
				}
			}
		}

		[ClientRpc]
		public void fixRespawnClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(67657836u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 67657836u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (SelectEffect.ReviveOpen)
				{
					SelectEffect.RefreshRevives();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void reviveNextServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3039924435u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3039924435u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)Instance).StartCoroutine(Revive.reviveNext());
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void reviveChanceServerRPC(float percentChance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(221188056u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref percentChance, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 221188056u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				if (val3.isPlayerDead && Random.value < percentChance)
				{
					RevivePlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val3), StartOfRound.Instance.middleOfShipNode.position);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RevivePlayerServerRpc(int ID, Vector3 SpawnPosition)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00db: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3347467633u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, ID);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref SpawnPosition);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3347467633u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (Misc.GetPlayerByUserID(ID).isPlayerDead)
				{
					fixRespawnClientRPC();
					RevivePlayerClientRpc(ID, SpawnPosition);
				}
			}
		}

		[ClientRpc]
		public void RevivePlayerClientRpc(int ID, Vector3 SpawnPosition)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00db: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3597900664u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, ID);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref SpawnPosition);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3597900664u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Revive.revivePlayer(ID, SpawnPosition);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddLifeAllServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(381327132u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 381327132u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				if (((NetworkBehaviour)val3).IsHost)
				{
					AddLifeToPlayer(val3);
				}
				else
				{
					AddLifeClientRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val3));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddLifeServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1581190059u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1581190059u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayerControllerB value = StartOfRound.Instance.allPlayerScripts[playerID];
					AddLifeClientRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, value));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SendMessageServerRPC(int clientID, string topMessage, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_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_0105: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(835406534u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, clientID);
				bool flag = topMessage != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(topMessage, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 835406534u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SendMessageClientRPC(clientID, topMessage, message);
			}
		}

		[ClientRpc]
		public void SendMessageClientRPC(int clientID, string topMessage, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_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_0105: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(29878885u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, clientID);
				bool flag = topMessage != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(topMessage, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 29878885u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance.localPlayerController != (Object)(object)StartOfRound.Instance.allPlayerScripts[clientID]))
				{
					Misc.SafeTipMessage(topMessage, message);
				}
			}
		}

		[ClientRpc]
		public void AddLifeClientRPC(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(654414994u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, clientID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 654414994u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				if (!((Object)(object)localPlayerController == (Object)null) && Misc.isPlayerLocal(clientID))
				{
					AddLifeToPlayer(localPlayerController);
				}
			}
		}

		private void AddLifeToPlayer(PlayerControllerB player)
		{
			if ((Object)(object)((Component)player).GetComponent<playerLifeController>() == (Object)null)
			{
				playerLifeController playerLifeController = ((Component)player).gameObject.AddComponent<playerLifeController>();
				playerLifeController.player = player;
			}
			((Component)player).GetComponent<playerLifeController>().addLife();
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportInsideServerRPC(int clientID, Vector3 teleportPos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00db: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4087975116u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref teleportPos);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4087975116u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportInsideClientRPC(clientID, teleportPos);
				}
			}
		}

		[ClientRpc]
		public void TeleportInsideClientRPC(int clientID, Vector3 teleportPos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00db: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2709139905u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref teleportPos);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2709139905u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportInside.TeleportPlayerInside(clientID, teleportPos);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MartyrdomServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(603695207u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 603695207u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					MartyrdomClientRPC();
				}
			}
		}

		[ClientRpc]
		public void MartyrdomClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(567713551u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 567713551u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Martyrdom.doMinesDrop = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doMartyrdomServerRPC(Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0089: 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_0104: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3858378172u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3858378172u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SpawnableMapObject val3 = GetEnemies.SpawnableLandmine;
				if (MysteryDice.SurfacedPresent)
				{
					val3 = ((Random.value > 0.5f) ? GetEnemies.Bertha : GetEnemies.Seamine);
				}
				GameObject val4 = Object.Instantiate<GameObject>(val3.prefabToSpawn, position, Quaternion.identity);
				NetworkObject componentInChildren = val4.GetComponentInChildren<NetworkObject>();
				componentInChildren.Spawn(true);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportToShipServerRPC(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2222788764u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2222788764u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportToShipClientRPC(clientID);
				}
			}
		}

		[ClientRpc]
		public void TeleportToShipClientRPC(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2386185210u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2386185210u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ReturnToShip.TeleportPlayerToShip(clientID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void despawnEnemyServerRpc(ulong enemyID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1449390942u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, enemyID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1449390942u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(enemyID, out var value))
			{
				return;
			}
			int num = 0;
			while (value.IsSpawned)
			{
				num++;
				if (((Object)((Component)value).gameObject).name != "Networker")
				{
					value.Despawn(true);
				}
				else
				{
					MysteryDice.CustomLogger.LogDebug((object)"Wat, why enemy named Networker??");
				}
				if (num >= 15)
				{
					Debug.LogWarning((object)$"Enemy tried to despawn {num} times and is still spawned.");
					break;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportToPlayerServerRPC(int clientID, int to)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2480012683u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					BytePacker.WriteValueBitPacked(val, to);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2480012683u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportToPlayerClientRPC(clientID, to);
				}
			}
		}

		[ClientRpc]
		public void TeleportToPlayerClientRPC(int clientID, int to)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(114950063u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					BytePacker.WriteValueBitPacked(val, to);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 114950063u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EveryoneToSomeone.TeleportPlayerToPlayer(clientID, to);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportOrBringPlayerServerRPC(int clientID, int clientID2, bool bring)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0097: 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_00b1: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1165488094u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					BytePacker.WriteValueBitPacked(val, clientID2);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref bring, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1165488094u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportOrBringPlayerClientRPC(clientID, clientID2, bring);
				}
			}
		}

		[ClientRpc]
		public void TeleportOrBringPlayerClientRPC(int clientID, int clientID2, bool bring)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0097: 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_00b1: 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_01ef: 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_0200: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(740943656u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, clientID);
				BytePacker.WriteValueBitPacked(val, clientID2);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref bring, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 740943656u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[clientID];
			PlayerControllerB val4 = StartOfRound.Instance.allPlayerScripts[clientID2];
			if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val4 == (Object)null) && !val3.isPlayerDead && !val4.isPlayerDead)
			{
				if (!bring)
				{
					val3.isInElevator = val4.isInElevator;
					val3.isInHangarShipRoom = val4.isInHangarShipRoom;
					val3.isInsideFactory = val4.isInsideFactory;
					val3.averageVelocity = val4.averageVelocity;
					val3.velocityLastFrame = val4.velocityLastFrame;
					val3.TeleportPlayer(((Component)val4).transform.position, false, 0f, false, true);
					val3.beamOutParticle.Play();
				}
				else
				{
					val4.isInElevator = val3.isInElevator;
					val4.isInHangarShipRoom = val3.isInHangarShipRoom;
					val4.isInsideFactory = val3.isInsideFactory;
					val4.averageVelocity = val3.averageVelocity;
					val4.velocityLastFrame = val3.velocityLastFrame;
					val4.TeleportPlayer(((Component)val3).transform.position, false, 0f, false, true);
					val4.beamOutParticle.Play();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportOrBringPlayerToPosServerRPC(Vector3 pos, int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_007e: 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_00db: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(140567396u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 140567396u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportOrBringPlayerToPosClientRPC(pos, userID);
				}
			}
		}

		[ClientRpc]
		public void TeleportOrBringPlayerToPosClientRPC(Vector3 pos, int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_007e: 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_00db: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1743878225u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
				BytePacker.WriteValueBitPacked(val, userID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1743878225u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB val3 = null;
			val3 = StartOfRound.Instance.allPlayerScripts[userID];
			if (!((Object)(object)val3 == (Object)null) && !val3.isPlayerDead)
			{
				val3.TeleportPlayer(pos, false, 0f, false, true);
				val3.beamOutParticle.Play();
				if (pos.y < -1000f)
				{
					val3.isInsideFactory = true;
				}
				else
				{
					val3.isInsideFactory = false;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EmergencyMeetingServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3030922208u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3030922208u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EmergencyMeetingClientRPC();
					InteractTrigger componentInChildren = GameObject.Find(StartOfRound.Instance.hangarDoorsClosed ? "StartButton" : "StopButton").GetComponentInChildren<InteractTrigger>();
					((UnityEvent<PlayerControllerB>)(object)componentInChildren.onInteract).Invoke(GameNetworkManager.Instance.localPlayerController);
					EmergencyMeeting.allEnemiesToShip();
					int intEmergency = MysteryDice.JumpscareScript.GetIntEmergency();
					EmergencyAllClientRPC(intEmergency);
				}
			}
		}

		[ClientRpc]
		public void EmergencyMeetingClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(645728860u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 645728860u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EmergencyMeeting.TeleportEveryoneToShip();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportPlayerToShipServerRPC(int plyr)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1130831606u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, plyr);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1130831606u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportPlayerToShipClientRPC(plyr);
				}
			}
		}

		[ClientRpc]
		public void TeleportPlayerToShipClientRPC(int plyr)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3851564758u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, plyr);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3851564758u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EmergencyMeeting.TeleportPlayerToShip(plyr);
				}
			}
		}

		[ClientRpc]
		public void EmergencyAllClientRPC(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2877773355u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, index);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2877773355u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					MysteryDice.JumpscareScript.Scare(index);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void suitStuffServerRPC(int clientID, int suit)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1013787913u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					BytePacker.WriteValueBitPacked(val, suit);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1013787913u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					suitStuffClientRPC(clientID, suit);
				}
			}
		}

		[ClientRpc]
		public void suitStuffClientRPC(int clientID, int suit)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2220492624u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, clientID);
				BytePacker.WriteValueBitPacked(val, suit);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2220492624u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			int suit2 = suit;
			if (!((Object)(object)StartOfRound.Instance.localPlayerController != (Object)(object)StartOfRound.Instance.allPlayerScripts[clientID]))
			{
				orderedSuits.Find((UnlockableSuit x) => x.syncedSuitID.Value == suit2).SwitchSuitToThis(StartOfRound.Instance.localPlayerController);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlaySoundFromGalServerRPC(string soundName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1103306623u, val2, (RpcDelivery)0);
				bool flag = soundName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(soundName, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1103306623u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)GalAI.Instances[0] == (Object)null))
				{
					((Component)GalAI.Instances[0]).GetComponent<DiceGalAI>().playSoundFromGalClientRPC(soundName);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlaySoundServerRPC(string sound)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1792589054u, val2, (RpcDelivery)0);
				bool flag = sound != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(sound, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1792589054u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlaySoundClientRPC(sound);
			}
		}

		[ClientRpc]
		public void PlaySoundClientRPC(string sound)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2685797276u, val2, (RpcDelivery)0);
				bool flag = sound != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(sound, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2685797276u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AudioSource val3 = default(AudioSource);
				if (!((Component)this).gameObject.TryGetComponent<AudioSource>(ref val3))
				{
					val3 = ((Component)this).gameObject.AddComponent<AudioSource>();
					val3.spatialBlend = 0f;
					val3.volume = MysteryDice.SoundVolume.Value;
					AudioSources.Add(val3);
				}
				MysteryDice.sounds.TryGetValue(sound, out var value);
				val3.clip = value;
				if ((Object)(object)val3.clip != (Object)null)
				{
					val3.Play();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BlockFireExitsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(758899621u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 758899621u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BlockFireExitsClientRPC();
				}
			}
		}

		[ClientRpc]
		public void BlockFireExitsClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(905636504u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 905636504u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FireExitPatch.AreFireExitsBlocked = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FakeFireExitsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3750907622u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3750907622u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FakeFireExitsClientRPC();
				}
			}
		}

		[ClientRpc]
		public void FakeFireExitsClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2557817672u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2557817672u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			GameObject[] array = Object.FindObjectsOfType<GameObject>(true);
			for (int i = 0; i < array.Length; i++)
			{
				if (((Object)array[i]).name.Contains("AlleyExitDoorContainer"))
				{
					array[i].SetActive(true);
				}
			}
		}

		[ClientRpc]
		public void MimicsClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4043194655u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 4043194655u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void InstaJesterServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(642114377u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 642114377u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					InstaJester.SpawnInstaJester();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void OutsideBrackenServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(117164783u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 117164783u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					OutsideBracken.SpawnOutsideBracken();
				}
			}
		}

		[ClientRpc]
		public void SetNavmeshBrackenClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(689662337u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 689662337u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					OutsideBracken.SetNavmeshBrackenClient();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MineOverflowServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1822380635u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1822380635u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					MineOverflow.SpawnMoreMines(MineOverflow.MaxMinesToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TPOverflowServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1885465351u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1885465351u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TPTraps.SpawnTeleporterTraps(TPTraps.MaxMinesToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void DoFollowerFanServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3530438928u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3530438928u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FollowerFan.giveFriend(player);
				}
			}
		}

		[ClientRpc]
		public void updateFanClientRpc(ulong netObject)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1935741099u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, netObject);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1935741099u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(netObject, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					FollowerFan.fixFan(gameObject);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TPOverflowOutsideServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2429683887u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2429683887u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					int minesToSpawn = Random.Range(TpOverflowOutside.MinMinesToSpawn, TpOverflowOutside.MaxMinesToSpawn + 1);
					TpOverflowOutside.SpawnTPOutside(minesToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpikeOverflowOutsideServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(327805513u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 327805513u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					int minesToSpawn = Random.Range(SpikeOverflowOutside.MinMinesToSpawn, SpikeOverflowOutside.MaxMinesToSpawn + 1);
					SpikeOverflowOutside.SpawnSpikeOutside(minesToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TulipTrapeezeServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(111759042u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 111759042u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TulipTrapeze.spawn();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TulipTrapeezeMessageServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1938579949u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1938579949u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TulipTrapeezeClientRPC(userID);
				}
			}
		}

		[ClientRpc]
		public void TulipTrapeezeClientRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3877144744u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3877144744u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
				if (Misc.isPlayerLocal(userID))
				{
					Misc.SafeTipMessage(" ", "I believe I can fly!");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void CustomTrapServerRPC(int max, string trap, bool inside, bool moving = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_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_00c8: 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_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)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1809311064u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, max);
				bool flag = trap != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(trap, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref inside, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref moving, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1809311064u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				DynamicTrapEffect.spawnTrap(max, trap, inside, 5f, moving);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void CustomScaledTrapServerRPC(int max, string trap, bool inside, Vector3 scale = default(Vector3), bool moving = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_0160: 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_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_00f6: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2864267276u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, max);
				bool flag = trap != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(trap, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref inside, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref scale);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref moving, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2864267276u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				DynamicTrapEffect.spawnTrap(max, trap, inside, 5f, moving, useScale: true, scale);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void spawnTrapOnServerRPC(string trap, int num, bool inside, int userID, bool usePos = false, Vector3 position = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_015c: 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_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_00ce: 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_00f0: 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_0117: 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_0180: 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_01b6: 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_01a0: 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_01f9: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4225785251u, val2, (RpcDelivery)0);
				bool flag = trap != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(trap, false);
				}
				BytePacker.WriteValueBitPacked(val, num);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref inside, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val, userID);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref usePos, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 4225785251u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
				Vector3 val3 = ((Component)playerByUserID).transform.position;
				if (usePos)
				{
					val3 = position;
				}
				trap trap2 = DynamicTrapEffect.getTrap(trap);
				GameObject val4 = ((!StartOfRound.Instance.inShipPhase) ? Object.Instantiate<GameObject>(trap2.prefab, val3, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform) : Object.Instantiate<GameObject>(trap2.prefab, val3, Quaternion.identity));
				val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
				val4.GetComponent<NetworkObject>().Spawn(true);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void CratesOutsideServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(337880440u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 337880440u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					int minesToSpawn = Random.Range(CratesOutside.MinMinesToSpawn, CratesOutside.MaxMinesToSpawn + 1);
					CratesOutside.SpawnCratesOutside(minesToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void IFeelSafeServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1991022u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1991022u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					IFeelSafe.SpawnCratesOutside();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnFreebirdJimothyServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1834581541u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1834581541u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FreebirdJimothy.spawnJimothy();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FreebirdJimothyServerRPC(ulong id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3113993560u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, id);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3113993560u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FreebirdJimothyClientRPC(id);
				}
			}
		}

		[ClientRpc]
		public void FreebirdJimothyClientRPC(ulong id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1474864547u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, id);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1474864547u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FreebirdJimothy.fixJimothy(id);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnFreebirdEnemyServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2824736702u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2824736702u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FreebirdEnemy.spawnEnemy();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnEvilFreebirdEnemyServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2194998330u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2194998330u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EvilFreebirdEnemy.spawnEnemy();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnFreebirdEnemyServerRPC(string name, bool outside, bool usePos = false, Vector3 pos = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0142: 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_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_00d6: 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_00fd: 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_0155: 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_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_01b3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(720705928u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref outside, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref usePos, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 720705928u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				Vector3 zero = Vector3.zero;
				if (usePos)
				{
					zero = pos;
				}
				else
				{
					RoundManager instance = RoundManager.Instance;
					EnemyVent val3 = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
					zero = (outside ? instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position : val3.floorNode.position);
				}
				FreebirdEnemy.spawnEnemy(name, zero);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnFreebirdTrapServerRPC(string name, bool random = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_011a: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2799833363u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref random, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2799833363u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				((MonoBehaviour)this).StartCoroutine(MovingFans.freebirdTrapSpawn(name, random));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FreebirdEnemyServerRPC(ulong id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2914505128u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, id);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2914505128u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FreebirdEnemyClientRPC(id);
				}
			}
		}

		[ClientRpc]
		public void FreebirdEnemyClientRPC(ulong id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(649136148u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, id);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 649136148u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FreebirdEnemy.fixEnemy(id);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EvilFreebirdEnemyServerRPC(ulong id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2323478769u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, id);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2323478769u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EvilFreebirdEnemyClientRPC(id);
				}
			}
		}

		[ClientRpc]
		public void EvilFreebirdEnemyClientRPC(ulong id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1396131715u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, id);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1396131715u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EvilFreebirdEnemy.fixEnemy(id);
				}
			}
		}

		[ClientRpc]
		public void FreebirdTrapClientRPC(ulong id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3162837376u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, id);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3162837376u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FreebirdEnemy.fixTrap(id);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void CratesInsideServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1069689894u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1069689894u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					int minesToSpawn = Random.Range(CratesInside.MinMinesToSpawn, CratesInside.MaxMinesToSpawn + 1);
					CratesOutside.SpawnCratesInside(minesToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SeaminesOutsideServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4177036667u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4177036667u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					int minesToSpawn = Random.Range(SeaminesOutside.MinMinesToSpawn, SeaminesOutside.MaxMinesToSpawn + 1);
					SeaminesOutside.SpawnSeaminesOutside(minesToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BruiserServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(509619746u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 509619746u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Bruiser.BruceInCruiser();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void HorseSeatServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1113219564u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1113219564u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HorseshootSeat.HorseSeat();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void DespawnObjectTimedServerRpc(ulong objectID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(595075450u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, objectID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 595075450u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(Bruiser.despawnObjectTimed(objectID));
				}
			}
		}

		[ClientRpc]
		public void DespawnObjectClientRpc(ulong objectID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1104638802u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1104638802u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectID, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					value.Despawn(true);
				}
			}
		}

		[ClientRpc]
		public void FixBruceClientRpc(ulong objectID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3192395886u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3192395886u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectID, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				Transform val3 = gameObject.transform.Find("PushTrigger_RedirectToRootNetworkObject");
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
				else
				{
					MysteryDice.CustomLogger.LogWarning((object)"PushTrigger_RedirectToRootNetworkObject not found!");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BaldServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1801495289u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1801495289u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Bald.SpawnBald(player);
				}
			}
		}

		[ClientRpc]
		public void FixBaldClientRpc(int player, ulong baldObject)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3673164621u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, player);
				BytePacker.WriteValueBitPacked(val, baldObject);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3673164621u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(baldObject, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					Bald.FixBald(player, gameObject);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetupChangeVoicesServerRpc(int[] keys, int[] values)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0157: 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_00ac: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1702338290u, val2, (RpcDelivery)0);
				bool flag = keys != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(keys, default(ForPrimitives));
				}
				bool flag2 = values != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(values, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1702338290u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SetupChangeVoicesClientRpc(keys, values);
			}
		}

		[ClientRpc]
		public void SetupChangeVoicesClientRpc(int[] keys, int[] values)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0157: 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_00ac: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3957042657u, val2, (RpcDelivery)0);
				bool flag = keys != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(keys, default(ForPrimitives));
				}
				bool flag2 = values != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(values, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3957042657u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			ChangeVoices.playerSwapInfo.Clear();
			if (keys == null || values == null || allPlayerScripts == null)
			{
				return;
			}
			int num = Mathf.Min(keys.Length, values.Length);
			for (int i = 0; i < num; i++)
			{
				int num2 = keys[i];
				int num3 = values[i];
				if ((uint)num2 < (uint)allPlayerScripts.Length && (uint)num3 < (uint)allPlayerScripts.Length)
				{
					ChangeVoices.playerSwapInfo[num2] = num3;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void HeheheServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3742567567u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3742567567u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HeheheClientRPC(player);
				}
			}
		}

		[ClientRpc]
		public void HeheheClientRPC(int client)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(716860219u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, client);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 716860219u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if ((Object)(object)StartOfRound.Instance.localPlayerController == (Object)(object)StartOfRound.Instance.allPlayerScripts[client])
			{
				if ((Object)(object)Hehehe.spiderCanvas == (Object)null)
				{
					Hehehe.spiderCanvas = Object.Instantiate<GameObject>(MysteryDice.SpiderCanvasPrefab);
				}
				if ((Object)(object)Hehehe.spiderCanvas != (Object)null)
				{
					Object.Instantiate<GameObject>(MysteryDice.SpiderMoverPrefab, Hehehe.spiderCanvas.transform);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BerthaOutsideServerRPC(int amount = 1)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(832386025u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, amount);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 832386025u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BerthaOutside.SpawnBerthaOutside(amount);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BIGBerthaServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3704408002u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3704408002u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BIGBertha.SpawnBIGBertha(1);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnSmolCraneServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3271572806u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3271572806u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SmolCrane.SpawnSmolCrane(1);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnBeegCraneServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(199626830u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 199626830u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BeegCrane.SpawnBeegCrane(1);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BIGSpikeServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(93332351u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 93332351u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BIGSpike.SpawnBIGSpike(Random.Range(1, 4));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void InstantExplodeBerthaServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2668117893u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2668117893u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					InstantExplodingBerthas.SpawnBerthaOutside(Random.Range(InstantExplodingBerthas.MinMinesToSpawn, InstantExplodingBerthas.MaxMinesToSpawn + 1));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void LongBerthaServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4025333853u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4025333853u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LongBertha.SpawnBerthaOutside(Random.Range(InstantExplodingBerthas.MinMinesToSpawn, InstantExplodingBerthas.MaxMinesToSpawn + 1));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void spawnMistressServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3517025756u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3517025756u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ManyMistress.SpawnMistress();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void scaleOverTimeServerRpc(ulong netObjID, float time, float maxYScale)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a5: 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_00bf: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3498325670u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, netObjID);
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref maxYScale, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3498325670u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					scaleOverTimeClientRpc(netObjID, time, maxYScale);
				}
			}
		}

		[ClientRpc]
		public void scaleOverTimeClientRpc(ulong netObjID, float time, float maxYScale)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a5: 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_00bf: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2228222119u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, netObjID);
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref maxYScale, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2228222119u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					setStretch(netObjID, maxYScale, time);
				}
			}
		}

		public static void setStretch(ulong objectID, float targetY, float time)
		{
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectID, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				((MonoBehaviour)Instance).StartCoroutine(StretchOverTime(targetY, time, gameObject.transform));
			}
		}

		private static IEnumerator StretchOverTime(float targetY, float time, Transform transform)
		{
			Vector3 initialScale = transform.localScale;
			Vector3 targetScale = new Vector3(initialScale.x, targetY, initialScale.z);
			float elapsedTime = 0f;
			while (elapsedTime < time)
			{
				transform.localScale = Vector3.Lerp(initialScale, targetScale, elapsedTime / time);
				elapsedTime += Time.deltaTime;
				yield return null;
			}
			transform.localScale = targetScale;
		}

		[ServerRpc(RequireOwnership = false)]
		public void setExplodedServerRpc(ulong berthaNetObj, float time)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a4: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1941287104u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, berthaNetObj);
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1941287104u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					setExplodedClientRpc(berthaNetObj, time);
				}
			}
		}

		[ClientRpc]
		public void setExplodedClientRpc(ulong berthaNetObj, float time)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a4: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3440863491u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, berthaNetObj);
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3440863491u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LongBertha.setExploded(berthaNetObj, time);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BerthaOnLeverServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2885808221u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2885808221u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BerthaLever.SpawnBerthaOnLever();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SkyFanServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1869804163u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1869804163u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SkyFan.SpawnSkyFan();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void setSuctionServerRPC(ulong objectId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3769819833u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, objectId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3769819833u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					setSuctionClientRPC(objectId);
				}
			}
		}

		[ClientRpc]
		public void setSuctionClientRPC(ulong objectId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3040266101u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3040266101u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectId, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					SkyFan.setSuck(gameObject);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doPaparazziServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3735209893u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3735209893u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Paparazzi.SpawnPaparazzi(Random.Range(Paparazzi.MinMinesToSpawn, Paparazzi.MaxMinesToSpawn + 1));
					AddMovingTrapClientRPC("Paparazzi");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doMovingCraneServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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_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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2747903296u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2747903296u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					trap trap2 = DynamicTrapEffect.getTrap("Autonomous Crane");
					GameObject val3 = Object.Instantiate<GameObject>(trap2.prefab, RoundManager.Instance.outsideAINodes[Random.Range(0, RoundManager.Instance.outsideAINodes.Length)].transform.position, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
					NetworkObject component = val3.GetComponent<NetworkObject>();
					component.Spawn(false);
					((Object)val3).name = "MovingCrane";
					AddMovingTrapClientRPC("MovingCrane");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doMadScienceServerRPC(int e)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_0151: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(874694681u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, e);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 874694681u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				List<EnemyType> list = GetEnemies.allEnemies.Where((EnemyType x) => !x.enemyName.ToLower().Contains("spider")).ToList();
				string enemyName = list[Random.Range(0, list.Count)].enemyName;
				TulipBombers.spawnAttachedEnemyCombo(e, enemyName, Misc.getAllTraps()[Random.Range(0, Misc.getAllTraps().Length)].name, Random.value > 0.5f, default(Vector3), 5f, default(Vector3), matchSize: true);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doTulipBomberServerRPC(int e)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3441359114u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, e);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3441359114u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string enemyName = GetEnemies.Tulip.enemyType.enemyName;
				string name = (from x in Misc.getAllTraps()
					where x.name.Contains("Landmine")
					select x).First().name;
				Vector3 sizeOfTrap = default(Vector3);
				((Vector3)(ref sizeOfTrap))..ctor(0.5f, 0.5f, 0.5f);
				TulipBombers.spawnAttachedEnemyCombo(e, enemyName, name, isOutside: true, default(Vector3), 5f, sizeOfTrap);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doImmortalSnailCatServerRPC(int e)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_0132: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1479493512u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, e);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1479493512u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string name = (from x in Misc.getAllTraps()
					where x.name.Contains("Landmine")
					select x).First().name;
				Vector3 sizeOfTrap = default(Vector3);
				((Vector3)(ref sizeOfTrap))..ctor(0.5f, 0.5f, 0.5f);
				TulipBombers.spawnAttachedEnemyCombo(e, "Real Enemy SnailCat", name, isOutside: true, default(Vector3), 5f, sizeOfTrap, matchSize: false, targetRandom: true);
			}
		}

		[ClientRpc]
		public void ScanSphereDisableClientRPC(ulong objectId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2707631037u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2707631037u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectId, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				Transform val3 = gameObject.transform.Find("ScanSphere");
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void makeLoverServerRPC(int p1, int p2)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(402860998u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, p1);
					BytePacker.WriteValueBitPacked(val, p2);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 402860998u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					makeLoverClientRPC(p1, p2);
				}
			}
		}

		[ClientRpc]
		public void makeLoverClientRPC(int p1, int p2)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(340750533u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, p1);
					BytePacker.WriteValueBitPacked(val, p2);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 340750533u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Lovers.makeLovers(p1, p2);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void makeBadLoverServerRPC(int p1, ulong enemyAI)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3627880505u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, p1);
					BytePacker.WriteValueBitPacked(val, enemyAI);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3627880505u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					makeBadLoverClientRPC(p1, enemyAI);
					PlaySoundClientRPC("Bad Romance");
				}
			}
		}

		[ClientRpc]
		public void makeBadLoverClientRPC(int p1, ulong enemyAI)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1295804991u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, p1);
					BytePacker.WriteValueBitPacked(val, enemyAI);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1295804991u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BadLovers.makeLovers(p1, enemyAI);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SilenceTPServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3851048414u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3851048414u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(SilentTP.SilenceAllTP(((NetworkBehaviour)this).IsServer));
					SilenceTPClientRPC();
				}
			}
		}

		[ClientRpc]
		public void SilenceTPClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(838689601u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 838689601u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsServer)
				{
					((MonoBehaviour)this).StartCoroutine(SilentTP.SilenceAllTP(((NetworkBehaviour)this).IsServer));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MineOverflowOutsideServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3354025460u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3354025460u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					MineOverflowOutside.SpawnMoreMinesOutside();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ModifyPitchNotifyServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2611363842u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2611363842u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ModifyPitchNotifyClientRPC();
				}
			}
		}

		[ClientRpc]
		public void ModifyPitchNotifyClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2473680354u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2473680354u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ModifyPitch.FluctuatePitch = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SwapPlayersServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1689679895u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1689679895u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB val3 = null;
				val3 = StartOfRound.Instance.allPlayerScripts[userID];
				int num = 0;
				num = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer(userID));
				if (!((Object)(object)val3 == (Object)null))
				{
					Swap.SwapPlayers(userID, num);
					SwapPlayerClientRPC(userID, num);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doSwapperServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(38229397u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 38229397u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ChangePlaces.doingStuff = true;
				}
			}
		}

		[ClientRpc]
		public void SwapPlayerClientRPC(int userID, int otherUserID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2060446871u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				BytePacker.WriteValueBitPacked(val, otherUserID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2060446871u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsServer)
				{
					Swap.SwapPlayers(userID, otherUserID);
				}
			}
		}

		[ClientRpc]
		public void swapAllPlayersClientRpc(int[] playerIDs, Vector3[] playerPositions, bool[] inside)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0194: 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_00ac: 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_0110: 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_01ba: 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_0134: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3440472779u, val2, (RpcDelivery)0);
				bool flag = playerIDs != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(playerIDs, default(ForPrimitives));
				}
				bool flag2 = playerPositions != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(playerPositions);
				}
				bool flag3 = inside != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(inside, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3440472779u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				for (int i = 0; i < playerIDs.Length; i++)
				{
					PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerIDs[i]];
					val3.isInsideFactory = inside[i];
					val3.TeleportPlayer(playerPositions[i], false, 0f, false, true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void JackpotServerRPC(int userID, int amount)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1727001893u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					BytePacker.WriteValueBitPacked(val, amount);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1727001893u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ScrapJackpot.JackpotScrap(userID, amount);
				}
			}
		}

		[ClientRpc]
		public void SyncItemWeightsClientRPC(NetworkObjectReference[] netObjs, float[] scrapWeights)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0157: 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_00ac: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2988314943u, val2, (RpcDelivery)0);
				bool flag = netObjs != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(netObjs, default(ForNetworkSerializable));
				}
				bool flag2 = scrapWeights != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(scrapWeights, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2988314943u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val3 = default(NetworkObject);
			for (int i = 0; i < netObjs.Length; i++)
			{
				if (((NetworkObjectReference)(ref netObjs[i])).TryGet(ref val3, (NetworkManager)null))
				{
					GrabbableObject component = ((Component)val3).GetComponent<GrabbableObject>();
					if ((Object)(object)component == (Object)null)
					{
						break;
					}
					component.itemProperties.weight = scrapWeights[i];
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MessageToEveryoneServerRPC(string title, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_013d: 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_00cc: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1402293360u, val2, (RpcDelivery)0);
				bool flag = title != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(title, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1402293360u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				MessageToEveryoneClientRPC(title, message);
			}
		}

		[ClientRpc]
		public void MessageToEveryoneClientRPC(string title, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_013d: 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_00cc: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2917276992u, val2, (RpcDelivery)0);
				bool flag = title != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(title, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2917276992u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				Misc.SafeTipMessage(title, message);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MessageToHostServerRPC(string title, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_013d: 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_00cc: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2289938095u, val2, (RpcDelivery)0);
				bool flag = title != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(title, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2289938095u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				MessageToHostClientRPC(title, message);
			}
		}

		[ClientRpc]
		public void MessageToHostClientRPC(string title, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_013d: 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_00cc: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2014332209u, val2, (RpcDelivery)0);
				bool flag = title != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(title, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2014332209u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (((NetworkBehaviour)this).IsServer || GameNetworkManager.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID)
				{
					Misc.SafeTipMessage(title, message);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void becomeAdminServerRPC(int userID, bool grant, bool forced = true)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a5: 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_00bf: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2677031213u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref grant, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref forced, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2677031213u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				becomeAdminClientRPC(userID, grant, forced);
				if (grant)
				{
					MysteryDice.revokedAdmins.Remove(StartOfRound.Instance.allPlayerScripts[userID].playerSteamId);
				}
				else
				{
					MysteryDice.revokedAdmins.Add(StartOfRound.Instance.allPlayerScripts[userID].playerSteamId);
				}
			}
		}

		[ClientRpc]
		public void becomeAdminClientRPC(int userID, bool grant, bool forced, bool noMessage = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a5: 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_00c0: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3841283509u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref grant, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref forced, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref noMessage, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3841283509u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!((Object)(object)StartOfRound.Instance.localPlayerController != (Object)(object)StartOfRound.Instance.allPlayerScripts[userID]))
			{
				if (forced)
				{
					MysteryDice.isAdmin = grant;
				}
				else
				{
					MysteryDice.isAdmin = !MysteryDice.isAdmin;
				}
				if (!noMessage)
				{
					Misc.SafeTipMessage(MysteryDice.isAdmin ? "Granted" : "Revoked", MysteryDice.isAdmin ? "You were granted admin privileges!" : "Your admin privileges were revoked.");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestAdminStateServerRpc(ulong steamId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(819957672u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, steamId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 819957672u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ulong steamId2 = steamId;
				bool flag = MysteryDice.revokedAdmins.Contains(steamId2);
				bool grant = MysteryDice.admins.Contains(steamId2) && !flag;
				int num = Array.FindIndex(StartOfRound.Instance.allPlayerScripts, (PlayerControllerB x) => (Object)(object)x != (Object)null && x.playerSteamId == steamId2);
				if (num >= 0)
				{
					becomeAdminClientRPC(num, grant, forced: true, noMessage: true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MicrowaveBerthaServerRPC(int num)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3263671255u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, num);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3263671255u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					MicrowaveBertha.spawnMicrowaveBertha(num);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void WhereGoServerRPC(int who)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1473440554u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, who);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1473440554u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					WhereGoClientRPC(who);
				}
			}
		}

		[ClientRpc]
		public void WhereGoClientRPC(int who)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3075898303u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, who);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3075898303u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					WhereDidMyFriendsGo.whereTheyGo(who);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doZortServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(77233678u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 77233678u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ZortinTwo.spawnZort(player);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doZortStuffServerRpc(ulong violin, ulong recorder, ulong accordian, ulong guitar)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_008b: 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_00b0: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2669257320u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, violin);
					BytePacker.WriteValueBitPacked(val, recorder);
					BytePacker.WriteValueBitPacked(val, accordian);
					BytePacker.WriteValueBitPacked(val, guitar);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2669257320u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					doZortStuffClientRpc(violin, recorder, accordian, guitar);
				}
			}
		}

		[ClientRpc]
		public void doZortStuffClientRpc(ulong v, ulong r, ulong a, ulong g)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_008b: 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_00b0: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(279242426u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, v);
				BytePacker.WriteValueBitPacked(val, r);
				BytePacker.WriteValueBitPacked(val, a);
				BytePacker.WriteValueBitPacked(val, g);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 279242426u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			List<AudioClip> list = new List<AudioClip>();
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(v, out var value) && NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(r, out var value2) && NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(a, out var value3) && NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(g, out var value4))
			{
				GameObject gameObject = ((Component)value).gameObject;
				GameObject gameObject2 = ((Component)value2).gameObject;
				GameObject gameObject3 = ((Component)value3).gameObject;
				GameObject gameObject4 = ((Component)value4).gameObject;
				AudioSource component = ((Component)gameObject.transform.Find("ViolinPlayer")).GetComponent<AudioSource>();
				AudioSource component2 = ((Component)gameObject2.transform.Find("RecorderPlayer")).GetComponent<AudioSource>();
				AudioSource component3 = ((Component)gameObject3.transform.Find("AccordionPlayer")).GetComponent<AudioSource>();
				AudioSource component4 = ((Component)gameObject4.transform.Find("GuitarPlayer")).GetComponent<AudioSource>();
				list.Add(component.clip);
				list.Add(component2.clip);
				list.Add(component3.clip);
				list.Add(component4.clip);
				List<AudioClip> list2 = list.OrderBy((AudioClip x) => Random.value).ToList();
				component.clip = list2[0];
				component2.clip = list2[1];
				component3.clip = list2[2];
				component4.clip = list2[3];
				component.volume = 0.5f;
				component2.volume = 0.5f;
				component3.volume = 0.5f;
				component4.volume = 0.5f;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SameScrapServerRPC(int userID, int amount, string scrap, bool usePos = false, Vector3 pos = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a2: 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_0141: 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_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_00fc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(910001296u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				BytePacker.WriteValueBitPacked(val, amount);
				bool flag = scrap != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(scrap, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref usePos, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 910001296u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AllSameScrap.SameScrap(userID, amount, scrap, usePos, pos);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SameScrapAdvancedServerRPC(int userID, int amount, string scrap, bool usePos = false, Vector3 pos = default(Vector3), int networkPrefabIndex = -1, float weightMod = 1f, float scrapValueMod = 1f)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a2: 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_0184: 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_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_00f1: 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_0110: 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_012b: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3232949610u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				BytePacker.WriteValueBitPacked(val, amount);
				bool flag = scrap != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(scrap, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref usePos, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
				BytePacker.WriteValueBitPacked(val, networkPrefabIndex);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref weightMod, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref scrapValueMod, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3232949610u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AllSameScrap.SameScrap(userID, amount, scrap, usePos, pos, networkPrefabIndex, weightMod, scrapValueMod);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AllOfOneTPServerRPC(NetworkObjectReference[] netObjs, int playerID, bool usePos, Vector3 pos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_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_00bc: 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_00fc: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2694207006u, val2, (RpcDelivery)0);
				bool flag = netObjs != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(netObjs, default(ForNetworkSerializable));
				}
				BytePacker.WriteValueBitPacked(val, playerID);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref usePos, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2694207006u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AllOfOneTPClientRPC(netObjs, playerID, usePos, pos);
			}
		}

		[ClientRpc]
		public void AllOfOneTPClientRPC(NetworkObjectReference[] netObjs, int playerID, bool usePos, Vector3 pos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_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_00bc: 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_00fc: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(692558469u, val2, (RpcDelivery)0);
				bool flag = netObjs != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(netObjs, default(ForNetworkSerializable));
				}
				BytePacker.WriteValueBitPacked(val, playerID);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref usePos, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 692558469u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AllSameScrap.teleport(netObjs, playerID, usePos, pos);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportEggServerRPC(NetworkObjectReference netObjs, int playerID, Vector3 pos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_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_00f6: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3837667048u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
					BytePacker.WriteValueBitPacked(val, playerID);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3837667048u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportEggClientRPC(netObjs, playerID, pos);
				}
			}
		}

		[ClientRpc]
		public void TeleportEggClientRPC(NetworkObjectReference netObjs, int playerID, Vector3 pos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1101246554u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
					BytePacker.WriteValueBitPacked(val, playerID);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1101246554u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggFountain.teleport(netObjs, playerID, pos);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FixGiftBoxesServerRPC(NetworkObjectReference[] netObjs)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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_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_0194: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2760557736u, val2, (RpcDelivery)0);
				bool flag = netObjs != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(netObjs, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2760557736u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val4 = default(NetworkObject);
			for (int i = 0; i < netObjs.Length; i++)
			{
				NetworkObjectReference val3 = netObjs[i];
				if (((NetworkObjectReference)(ref val3)).TryGet(ref val4, (NetworkManager)null))
				{
					GiftBoxItem component = ((Component)val4).GetComponent<GiftBoxItem>();
					if ((Object)(object)component != (Object)null)
					{
						Item val5 = StartOfRound.Instance.allItemsList.itemsList[Random.Range(0, StartOfRound.Instance.allItemsList.itemsList.Count)];
						int val6 = Random.Range(val5.minValue, val5.maxValue);
						FixGiftBoxesClientRPC(NetworkObjectReference.op_Implicit(val4), val5.itemName, val6);
					}
				}
			}
		}

		[ClientRpc]
		public void FixGiftBoxesClientRPC(NetworkObjectReference netObjref, string itemName, int val)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_00a3: 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_0127: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val3 = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(245144263u, val3, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref netObjref, default(ForNetworkSerializable));
				bool flag = itemName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(itemName, false);
				}
				BytePacker.WriteValueBitPacked(val2, val);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 245144263u, val3, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			string itemName2 = itemName;
			NetworkObject val4 = default(NetworkObject);
			if (!((NetworkObjectReference)(ref netObjref)).TryGet(ref val4, (NetworkManager)null))
			{
				return;
			}
			GiftBoxItem component = ((Component)val4).GetComponent<GiftBoxItem>();
			if ((Object)(object)component != (Object)null)
			{
				Item val5 = StartOfRound.Instance.allItemsList.itemsList.Find((Item x) => x.itemName.Equals(itemName2, StringComparison.OrdinalIgnoreCase));
				if ((Object)(object)val5 != (Object)null)
				{
					component.objectInPresentItem = val5;
					component.objectInPresent = val5.spawnPrefab;
					component.objectInPresentValue = val;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void spicyNuggiesServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3712040132u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3712040132u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SpicyNuggies.Spawn();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void HouseWinServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2141086692u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2141086692u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HouseAlwaysWins.Spawn();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void spawnStoreItemServerRPC(int playerID, string itemName, Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_0121: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1905863534u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				bool flag = itemName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(itemName, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1905863534u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				RandomStoreItem.SpawnItemNamed(playerID, itemName, position);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void CustomMonsterServerRPC(string monsterName, int AmountMin, int AmountMax, bool IsInside)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0134: 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_0147: 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_00bc: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3289246364u, val2, (RpcDelivery)0);
				bool flag = monsterName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(monsterName, false);
				}
				BytePacker.WriteValueBitPacked(val, AmountMin);
				BytePacker.WriteValueBitPacked(val, AmountMax);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref IsInside, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3289246364u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				DynamicEffect.spawnEnemy(monsterName, AmountMin, AmountMax, IsInside);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnEnemyAtPosServerRPC(string name, Vector3 pos, bool useSize = false, Vector3 size = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0134: 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_00ce: 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_01ca: 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_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_0216: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(290308596u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe(ref pos);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref useSize, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe(ref size);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 290308596u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			string name2 = name;
			List<EnemyType> source = GetEnemies.allEnemies.ToList();
			EnemyType val3 = ((IEnumerable<EnemyType>)source).FirstOrDefault((Func<EnemyType, bool>)((EnemyType x) => x.enemyName == name2));
			if ((Object)(object)val3 == (Object)null)
			{
				MysteryDice.CustomLogger.LogWarning((object)("Enemy '" + name2 + "' not found. Available enemies: " + string.Join(", ", source.Select((EnemyType e) => e.enemyName))));
				return;
			}
			GameObject val4 = Object.Instantiate<GameObject>(val3.enemyPrefab, pos, Quaternion.identity);
			NetworkObject componentInChildren = val4.GetComponentInChildren<NetworkObject>();
			componentInChildren.Spawn(false);
			RoundManager.Instance.SpawnedEnemies.Add(val4.GetComponent<EnemyAI>());
			if (useSize)
			{
				setSizeClientRPC(componentInChildren.NetworkObjectId, size);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EggFountainServerRPC(int userID, int use)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4191636483u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					BytePacker.WriteValueBitPacked(val, use);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4191636483u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggFountain.spawnEggs(userID, use);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void explodeItemServerRPC(ulong objectId, bool egg, int count, Vector3 position = default(Vector3))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0099: 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_0103: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1371214004u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, objectId);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref egg, default(ForPrimitives));
					BytePacker.WriteValueBitPacked(val, count);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1371214004u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					explodeItemClientRPC(objectId, egg, count, position);
				}
			}
		}

		[ClientRpc]
		public void explodeItemClientRPC(ulong objectId, bool egg, int count, Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0099: 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_0103: 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_0130: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2557813352u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objectId);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref egg, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val, count);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2557813352u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objectId, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				if (position != default(Vector3))
				{
					gameObject.GetComponent<GrabbableObject>().FallToGround(false, true, position);
				}
				if (egg)
				{
					((MonoBehaviour)RoundManager.Instance).StartCoroutine(EggFountain.explodeEgg(gameObject, count));
				}
				else
				{
					((MonoBehaviour)RoundManager.Instance).StartCoroutine(EggFountain.explodeStun(gameObject));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doEvilCutieFlyServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2508452677u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2508452677u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HeatSeakingCutieFly.doSpawnCutie();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void turretMineExploderServerRPC(bool turret)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3191841926u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref turret, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3191841926u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (turret)
				{
					TurretExploder.explodeAllMines();
				}
				else
				{
					MineExploder.explodeAllMines();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doRedPillStuffServerRPC(bool bald, bool freebird = false, bool fish = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0098: 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_00b3: 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_0112: 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_0175: 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_0191: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1637841621u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref bald, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref freebird, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref fish, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1637841621u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				EnemyType val3 = GetEnemies.allEnemies.Find((EnemyType x) => x.enemyName == "Red pill");
				Vector3 position = RoundManager.Instance.insideAINodes[Random.Range(0, RoundManager.Instance.insideAINodes.Length)].gameObject.transform.position;
				GameObject val4 = Object.Instantiate<GameObject>(val3.enemyPrefab, position, Quaternion.identity);
				NetworkObject component = val4.GetComponent<NetworkObject>();
				component.Spawn(false);
				NetworkObjectReference enemyRef = NetworkObjectReference.op_Implicit(component);
				RoundManager.Instance.SpawnedEnemies.Add(val4.GetComponent<EnemyAI>());
				doRedPillFixClientRPC(bald, fish, enemyRef);
				if (freebird)
				{
					Instance.FreebirdEnemyServerRPC(((NetworkObjectReference)(ref enemyRef)).NetworkObjectId);
				}
			}
		}

		[ClientRpc]
		public void doRedPillFixClientRPC(bool bald, bool fish, NetworkObjectReference enemyRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0098: 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_00b3: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(101530073u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref bald, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref fish, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref enemyRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 101530073u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val3 = default(NetworkObject);
			if (((NetworkObjectReference)(ref enemyRef)).TryGet(ref val3, (NetworkManager)null))
			{
				GameObject gameObject = ((Component)val3).gameObject;
				RedPillChanger redPillChanger = gameObject.GetComponent<RedPillChanger>();
				if ((Object)(object)redPillChanger == (Object)null)
				{
					redPillChanger = gameObject.AddComponent<RedPillChanger>();
				}
				Material redPillMaterial = (fish ? MysteryDice.angyFish : (bald ? MysteryDice.angyGlitch : MysteryDice.jobApplication));
				redPillChanger.RedPillMaterial = redPillMaterial;
				redPillChanger.RedPill = ((Component)val3).gameObject;
				redPillChanger.isBald = true;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void HealAllServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(651724430u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 651724430u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HealAllClientRPC();
				}
			}
		}

		[ClientRpc]
		public void HealAllClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(253654510u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 253654510u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			GameObject[] allPlayerObjects = StartOfRound.Instance.allPlayerObjects;
			foreach (GameObject val3 in allPlayerObjects)
			{
				PlayerControllerB component = val3.GetComponent<PlayerControllerB>();
				if ((Object)(object)component == (Object)null || !Misc.IsPlayerAliveAndControlled(component))
				{
					continue;
				}
				Heal(component);
				HUDManager.Instance.UpdateHealthUI(component.health, false);
				GrabbableObject[] itemSlots = component.ItemSlots;
				foreach (GrabbableObject val4 in itemSlots)
				{
					if (!((Object)(object)val4 == (Object)null) && val4.insertedBattery != null)
					{
						val4.insertedBattery.charge = 1f;
						val4.insertedBattery.empty = false;
					}
				}
			}
		}

		public static void Heal(PlayerControllerB player)
		{
			player.bleedingHeavily = false;
			player.criticallyInjured = false;
			if (player.health < 100)
			{
				player.health = 100;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TurnOffAllLightsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1611098485u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1611098485u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TurnOffAllLightsClientRPC();
				}
			}
		}

		[ClientRpc]
		public void TurnOffAllLightsClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(569249862u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 569249862u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				RoundManager.Instance.TurnOnAllLights(false);
				BreakerBox val3 = Object.FindObjectOfType<BreakerBox>();
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
			}
		}

		private void RebelCoilheads()
		{
			if (!RebeliousCoilHeads.IsEnabled)
			{
				CoilheadIgnoreStares = false;
				return;
			}
			RebelTimer -= Time.deltaTime;
			if (RebelTimer <= 0f)
			{
				CoilheadIgnoreStares = !CoilheadIgnoreStares;
				if (CoilheadIgnoreStares)
				{
					RebelTimer = Random.Range(2f, 3f);
				}
				else
				{
					RebelTimer = Random.Range(12f, 20f);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EnableRebelServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3467711789u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3467711789u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RebeliousCoilHeads.IsEnabled = true;
					Misc.SpawnEnemyForced(GetEnemies.Coilhead, 1, isInside: true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ReturnPlayerToShipServerRPC(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3182374205u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, clientID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3182374205u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportToShipClientRPC(clientID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnBeehivesServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3343372220u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3343372220u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Beepocalypse.SpawnBeehives();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void fixBehiveSizeServerRPC(ulong netID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2609470227u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, netID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2609470227u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					fixBehiveSizeClientRPC(netID);
				}
			}
		}

		[ClientRpc]
		public void fixBehiveSizeClientRPC(ulong netID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(144497274u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, netID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 144497274u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(netID, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					gameObject.transform.localScale = new Vector3(15f, 15f, 15f);
				}
			}
		}

		[ClientRpc]
		public void ZeroOutBeehiveScrapClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(141816624u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 141816624u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(ZeroScrapDelay());
				}
			}
		}

		public IEnumerator ZeroScrapDelay()
		{
			yield return (object)new WaitForSeconds(4f);
			Beepocalypse.ZeroAllBeehiveScrap();
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnWormssServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1024578127u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1024578127u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Wormageddon.SpawnWorms();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetArmageddonServerRPC(bool enable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3302520548u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref enable, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3302520548u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Armageddon.IsEnabled = enable;
				}
			}
		}

		[ClientRpc]
		public void DetonateAtPosClientRPC(Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0089: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1129990815u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1129990815u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Landmine.SpawnExplosion(position, true, 1f, 5f, 50, 0f, (GameObject)null, false);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void JumpscareAllServerRPC(int sync)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4180608942u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, sync);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4180608942u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					JumpscareAllClientRPC(sync);
				}
			}
		}

		[ClientRpc]
		public void JumpscareAllClientRPC(int sync)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1666284665u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, sync);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1666284665u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					MysteryDice.JumpscareScript.Scare(sync);
				}
			}
		}

		public IEnumerator DelayJumpscare(int sync)
		{
			yield return (object)new WaitForSeconds(Random.Range(10f, 60f));
			JumpscareAllServerRPC(sync);
		}

		[ServerRpc(RequireOwnership = false)]
		public void AlarmCurseServerRPC(Vector3 position, int AudioNum = 0, bool isGlitch = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_007e: 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_009d: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4156720066u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
					BytePacker.WriteValueBitPacked(val, AudioNum);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref isGlitch, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4156720066u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AlarmCurse.AlarmAudio(position, AudioNum, isGlitch);
					AlarmCurseClientRPC(position, AudioNum, isGlitch);
				}
			}
		}

		[ClientRpc]
		public void AlarmCurseClientRPC(Vector3 position, int AudioNum, bool isGlitch)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: 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_007e: 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_009d: 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_00f6: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1028527772u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
				BytePacker.WriteValueBitPacked(val, AudioNum);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref isGlitch, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1028527772u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsServer)
				{
					AlarmCurse.AlarmAudio(position, AudioNum, isGlitch);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void targetPracticeServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_00f9: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2750078957u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2750078957u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerID];
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)val3).transform.position;
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (!((Object)(object)spawnedEnemy.agent == (Object)null))
				{
					spawnedEnemy.targetPlayer = val3;
					spawnedEnemy.movingTowardsTargetPlayer = true;
					spawnedEnemy.moveTowardsDestination = true;
					spawnedEnemy.agent.SetDestination(position);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnObjectServerRPC(int user, int amount, string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a2: 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_0119: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3516264184u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, user);
				BytePacker.WriteValueBitPacked(val, amount);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3516264184u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SpawnObjectClientRPC(user, amount, name);
			}
		}

		[ClientRpc]
		public void SpawnObjectClientRPC(int user, int amount, string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a2: 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_0119: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(211938818u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, user);
				BytePacker.WriteValueBitPacked(val, amount);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 211938818u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AllSameScrap.spawnObject(user, amount, name);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AdObjectServerRPC(string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(134965558u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 134965558u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AdObjectClientRPC(name, ManyAds.getTopText(), ManyAds.getBottomText());
			}
		}

		[ClientRpc]
		public void AdObjectClientRPC(string name, string top, string bottom)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_017b: 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_00cc: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2959062392u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				bool flag2 = top != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(top, false);
				}
				bool flag3 = bottom != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(bottom, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2959062392u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string name2 = name;
				SpawnableOutsideObject val3 = GetEnemies.allObjects.First((SpawnableOutsideObject x) => ((Object)x).name == name2);
				ManyAds.QueueAd(isTool: false, name2, top, bottom, isObject: true, val3.prefabToSpawn);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AdEnemyServerRPC(string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3372655922u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3372655922u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				AdEnemyClientRPC(name, ManyAds.getTopText(), ManyAds.getBottomText());
			}
		}

		[ClientRpc]
		public void AdEnemyClientRPC(string name, string top, string bottom)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_017b: 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_00cc: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2257413543u, val2, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(name, false);
				}
				bool flag2 = top != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(top, false);
				}
				bool flag3 = bottom != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(bottom, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2257413543u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string name2 = name;
				EnemyType val3 = GetEnemies.allEnemies.First((EnemyType x) => ((Object)x).name == name2);
				ManyAds.QueueAd(isTool: false, name2, top, bottom, isObject: true, val3.enemyPrefab);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void forcedFriendshipServerRPC(int playerID, bool stuck = false, int min = 2, int max = 4)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0099: 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_00be: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3847537304u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref stuck, default(ForPrimitives));
					BytePacker.WriteValueBitPacked(val, min);
					BytePacker.WriteValueBitPacked(val, max);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3847537304u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BombCollars.spawnCollars(playerID, stuck, min, max);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void everyoneFriendsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1314177342u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1314177342u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BombCollars.EveryoneIsFriendsNow();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void DoorlockServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(471580845u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 471580845u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					InvertDoorLock.InvertDoors();
					DoorlockClientRPC();
				}
			}
		}

		[ClientRpc]
		public void DoorlockClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2317206841u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2317206841u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsServer)
				{
					InvertDoorLock.InvertDoors();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ZombieToShipServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2857123715u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2857123715u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ZombieToShip.ZombieUseServer(userID);
				}
			}
		}

		[ClientRpc]
		public void ZombieSuitClientRPC(NetworkObjectReference netObj, int suitID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_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_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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(583255447u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref netObj, default(ForNetworkSerializable));
					BytePacker.WriteValueBitPacked(val, suitID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 583255447u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ZombieToShip.ZombieSetSuit(netObj, suitID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestToSyncSuitIDServerRPC(NetworkObjectReference zombieNet)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(911839294u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref zombieNet, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 911839294u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ZombieToShip.ZombieSyncData(zombieNet);
				}
			}
		}

		[ClientRpc]
		public void SyncSuitIDClientRPC(NetworkObjectReference zombieNet, int zombieSuitID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_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_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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2960123516u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref zombieNet, default(ForNetworkSerializable));
					BytePacker.WriteValueBitPacked(val, zombieSuitID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2960123516u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ZombieToShip.ZombieSetSuit(zombieNet, zombieSuitID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SilenceMinesServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(187663145u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 187663145u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(SilentMine.SilenceAllMines(((NetworkBehaviour)this).IsServer));
					SilenceMinesClientRPC();
				}
			}
		}

		[ClientRpc]
		public void SilenceMinesClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3991829361u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3991829361u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsServer)
				{
					((MonoBehaviour)this).StartCoroutine(SilentMine.SilenceAllMines(((NetworkBehaviour)this).IsServer));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TuretHellServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1079351248u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1079351248u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TurretPatch.FastCharging = true;
					TurretHell.SpawnTurrets(TurretHell.MaxTurretsToSpawn);
					TurretHellClientRPC();
				}
			}
		}

		[ClientRpc]
		public void TurretHellClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(762161338u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 762161338u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TurretPatch.FastCharging = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ShipTurretServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3912816191u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3912816191u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ShipTurret.SpawnTurretsShip(ShipTurret.MaxTurretsToSpawn);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnPetDogServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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_00e1: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1923849739u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1923849739u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GameObject val3 = Object.Instantiate<GameObject>(GetEnemies.Dog.enemyType.enemyPrefab, ((Component)Misc.GetRandomAlivePlayer()).transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
					NetworkObject component = val3.GetComponent<NetworkObject>();
					component.Spawn(false);
					RoundManager.Instance.SpawnedEnemies.Add(val3.GetComponent<EnemyAI>());
					fixDogClientRPC(component.NetworkObjectId);
					setSizeClientRPC(component.NetworkObjectId, new Vector3(0.25f, 0.25f, 0.25f));
				}
			}
		}

		[ClientRpc]
		public void fixDogClientRPC(ulong objID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4203928006u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 4203928006u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objID, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				EnemyAICollisionDetect[] componentsInChildren = gameObject.GetComponentsInChildren<EnemyAICollisionDetect>();
				EnemyAICollisionDetect[] array = componentsInChildren;
				foreach (EnemyAICollisionDetect val3 in array)
				{
					Object.Destroy((Object)(object)val3);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnDongServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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_00e1: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3919335840u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3919335840u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GameObject val3 = Object.Instantiate<GameObject>(GetEnemies.Maneater.enemyType.enemyPrefab, ((Component)Misc.GetRandomAlivePlayer()).transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
					NetworkObject component = val3.GetComponent<NetworkObject>();
					component.Spawn(false);
					RoundManager.Instance.SpawnedEnemies.Add(val3.GetComponent<EnemyAI>());
					putThingOnDongClientRPC(component.NetworkObjectId);
					setSizeClientRPC(component.NetworkObjectId, new Vector3(0.25f, 0.25f, 0.25f));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void paperCutServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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_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_0142: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4251728437u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 4251728437u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Vector3 one = Vector3.one;
			one.z = 0.1f;
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (!(spawnedEnemy.enemyType.enemyName == "Transporter") && !(spawnedEnemy.enemyType.enemyName == "Bruce"))
				{
					NetworkObject component = ((Component)spawnedEnemy).gameObject.GetComponent<NetworkObject>();
					setSizeClientRPC(component.NetworkObjectId, one);
				}
			}
		}

		[ClientRpc]
		public void putThingOnDongClientRPC(ulong objID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(416980391u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, objID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 416980391u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(objID, out var value))
				{
					GameObject gameObject = ((Component)value).gameObject;
					ManeaterPatchThing maneaterPatchThing = gameObject.AddComponent<ManeaterPatchThing>();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ShotgunServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2582859660u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2582859660u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Shotgun.SpawnShotgun(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PokeballsServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2298116725u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2298116725u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					CatchEmAll.SpawnPokeballs(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MasterballServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3350416249u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3350416249u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LegendaryCatch.SpawnMasterball(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PathfinderSpawnBlobsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(572928773u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 572928773u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Pathfinder.SpawnBlobs();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PathfinderGiveSpawnerServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1920027461u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1920027461u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Pathfinder.GiveBlobItem(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void InfiniteStaminaAllServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4050797297u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4050797297u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					InfiniteStaminaAllClientRPC();
				}
			}
		}

		[ClientRpc]
		public void InfiniteStaminaAllClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4216319249u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 4216319249u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayerControllerBPatch.HasInfiniteStamina = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PurgeServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(882682875u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 882682875u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PurgeClientRPC();
				}
			}
		}

		[ClientRpc]
		public void PurgeClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3689629835u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3689629835u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Purge.PurgeAllEnemies();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void StartMalfunctioningServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1280047076u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1280047076u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (DoorMalfunctioning != null)
				{
					((MonoBehaviour)this).StopCoroutine(DoorMalfunctioning);
				}
				DoorMalfunctioning = ((MonoBehaviour)this).StartCoroutine(DoorBrokenLoop());
			}
		}

		private IEnumerator DoorBrokenLoop()
		{
			while (true)
			{
				DoorMalfunctionClientRPC(closed: true);
				yield return (object)new WaitForSeconds(Random.Range(1f, 7f));
				DoorMalfunctionClientRPC(closed: false);
				yield return (object)new WaitForSeconds(Random.Range(0.5f, 4f));
			}
		}

		[ClientRpc]
		public void DoorMalfunctionClientRPC(bool closed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2064573050u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref closed, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2064573050u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					DoorMalfunction.SetHangarDoorsState(closed);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddMoneyServerRPC(int money)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(300764022u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, money);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 300764022u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				int num = 0;
				Terminal val3 = Object.FindFirstObjectByType<Terminal>();
				num = val3.groupCredits + money;
				if (num < 0)
				{
					num = 0;
				}
				val3.SyncGroupCreditsClientRpc(num, val3.numberOfItemsInDropship);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TimeScaleServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3254398305u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3254398305u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TimeScaleClientRPC();
				}
			}
		}

		[ClientRpc]
		public void TimeScaleClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(363698876u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 363698876u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Time.timeScale = 3f;
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(fixTime());
				}
			}
		}

		private IEnumerator fixTime()
		{
			yield return (object)new WaitForSecondsRealtime(10f);
			Time.timeScale = 1f;
		}

		[ServerRpc(RequireOwnership = false)]
		public void BigDeliveryServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1077131223u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1077131223u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)RoundManager.Instance).IsServer)
			{
				return;
			}
			Terminal val3 = Object.FindObjectOfType<Terminal>();
			int num = Random.Range(3, 7);
			List<int> list = new List<int>();
			for (int i = 0; i < val3.buyableItemsList.Length; i++)
			{
				if (val3.buyableItemsList[i].creditsWorth >= 10 && val3.buyableItemsList[i].creditsWorth <= 1000)
				{
					list.Add(i);
				}
			}
			for (int j = 0; j < num; j++)
			{
				int item = list[Random.Range(0, list.Count)];
				val3.orderedItemsFromTerminal.Add(item);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void IncreaseRateServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1031158208u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1031158208u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TimeOfDayPatch.AdditionalBuyingRate += Random.Range(0.2f, 0.6f);
					StartOfRound instance = StartOfRound.Instance;
					instance.companyBuyingRate += TimeOfDayPatch.AdditionalBuyingRate;
					SyncRateClientRPC(StartOfRound.Instance.companyBuyingRate);
				}
			}
		}

		[ClientRpc]
		public void SyncRateClientRPC(float companyRate)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2814116775u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref companyRate, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2814116775u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					StartOfRound.Instance.companyBuyingRate = companyRate;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnMeteorsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3574076843u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3574076843u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!Meteors.isRunning)
				{
					TimeOfDay.Instance.MeteorWeather.SetStartMeteorShower();
					SpawnMeteorsClientRPC();
				}
			}
		}

		[ClientRpc]
		public void SpawnMeteorsClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2190384021u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2190384021u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Meteors.isRunning = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ForceTakeoffServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3892095964u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3892095964u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ForceTakeoffClientRPC();
				}
			}
		}

		[ClientRpc]
		public void ForceTakeoffClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2908385801u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2908385801u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					StartOfRound.Instance.ShipLeaveAutomatically(false);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void FlashbrightServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1151577352u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1151577352u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FlashbrightClientRPC();
				}
			}
		}

		[ClientRpc]
		public void FlashbrightClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1359570172u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1359570172u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BrightFlashlight.IsEnabled = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ArachnophobiaServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1998713722u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1998713722u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ArachnophobiaClientRPC();
					Arachnophobia.SpawnSpiders();
				}
			}
		}

		[ClientRpc]
		public void ArachnophobiaClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3091144464u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3091144464u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Arachnophobia.IsEnabled = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void OutsideCoilheadServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2481313195u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2481313195u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					OutsideCoilhead.SpawnOutsideCoilhead();
				}
			}
		}

		public IEnumerator ServerDelayedCoilheadSetProperties(NetworkObjectReference netObj)
		{
			//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)
			yield return (object)new WaitForSeconds(5f);
			SetCoilheadNavmeshClientRPC(((NetworkObjectReference)(ref netObj)).NetworkObjectId);
		}

		[ClientRpc]
		public void SetCoilheadNavmeshClientRPC(ulong netID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2759873561u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, netID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2759873561u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (spawnedEnemy is SpringManAI && ((NetworkBehaviour)spawnedEnemy).NetworkObjectId == netID)
				{
					OutsideCoilhead.SetNavmesh(spawnedEnemy, outside: true);
					spawnedEnemy.EnableEnemyMesh(true, false, false);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MovingMinesInitServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(146844497u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 146844497u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					MineOverflow.SpawnMoreMines(5);
					AddMovingMinesClientRPC();
				}
			}
		}

		[ClientRpc]
		public void AddMovingMinesClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2783863187u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2783863187u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(MovingFans.WaitForTrapInit(((Object)GetEnemies.SpawnableLandmine.prefabToSpawn).name));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MovingBeartrapsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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_00d7: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1328528021u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1328528021u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					DynamicTrapEffect.spawnTrap(3, "GravelBeartrap", inside: false);
					MovingBeartrapsClientRPC();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MovingCratesServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(947103770u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 947103770u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(MovingCrates.MakeMovingCrates());
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void CrateOpenServerRPC(ulong netID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(949600809u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, netID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 949600809u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(MovingCrates.crateOpener(netID));
				}
			}
		}

		[ClientRpc]
		public void MovingBeartrapsClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3599904130u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3599904130u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(MovingFans.WaitForTrapInit("Beartrap"));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SuperFlingerServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4123855474u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4123855474u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Horseshootnt.spawnFlinger(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void CleaningCrewServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3784076443u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3784076443u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					CleaningCrew.spawnCrew(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MovingFansServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1182949054u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1182949054u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					CustomTrapServerRPC(6, ((Object)GetEnemies.Fan.prefabToSpawn).name, inside: false);
					AddMovingTrapClientRPC(((Object)GetEnemies.Fan.prefabToSpawn).name);
				}
			}
		}

		[ClientRpc]
		public void AddMovingTrapClientRPC(string trapName, bool follower = false, int playerFollowing = 0)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_0127: 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_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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2873323906u, val2, (RpcDelivery)0);
				bool flag = trapName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(trapName, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref follower, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val, playerFollowing);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2873323906u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				((MonoBehaviour)this).StartCoroutine(MovingFans.WaitForTrapInit(trapName, follower, playerFollowing));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MovingSeatrapsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(373099070u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 373099070u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SeaminesOutsideServerRPC();
					BerthaOutsideServerRPC(3);
					AddMovingSeatrapsClientRPC();
				}
			}
		}

		[ClientRpc]
		public void AddMovingSeatrapsClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2952040135u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2952040135u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(MovingFans.WaitForTrapInit("Bertha"));
					((MonoBehaviour)this).StartCoroutine(MovingFans.WaitForTrapInit("Seamine"));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void MovingTrapsInitServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(523761332u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 523761332u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TPTraps.SpawnTeleporterTraps(5);
					AddMovingTrapClientRPC(((Object)GetEnemies.SpawnableTP.prefabToSpawn).name);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void HyperShakeServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1503931313u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1503931313u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			GameObject[] allPlayerObjects = StartOfRound.Instance.allPlayerObjects;
			foreach (GameObject val3 in allPlayerObjects)
			{
				PlayerControllerB component = val3.GetComponent<PlayerControllerB>();
				if (Misc.IsPlayerAliveAndControlled(component))
				{
					list.Add(component);
				}
			}
			PlayerControllerB value = list[Random.Range(0, list.Count)];
			HyperShakeClientRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, value));
		}

		[ClientRpc]
		public void HyperShakeClientRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(804710399u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 804710399u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (Misc.isPlayerLocal(playerID))
				{
					HyperShake.ShakeData shakeData = new HyperShake.ShakeData();
					shakeData.Player = GameNetworkManager.Instance.localPlayerController;
					shakeData.NextShakeTimer = 0f;
					shakeData.ShakingTimer = 0f;
					HyperShake.ShakingData = shakeData;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void LeverShakeServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(456732040u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 456732040u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LeverShake.ServerUse();
					LeverShakeClientRPC();
				}
			}
		}

		[ClientRpc]
		public void LeverShakeClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2127593152u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 2127593152u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LeverShake.ClientsUse();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void NeckBreakRandomPlayerServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2572659893u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, player);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2572659893u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					NeckBreakRandomPlayerClientRpc(player);
				}
			}
		}

		[ClientRpc]
		public void NeckBreakRandomPlayerClientRpc(int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2108188472u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2108188472u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded && Misc.isPlayerLocal(playerId))
				{
					NeckBreak.BreakNeck();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void NeckSpinRandomPlayerServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3224606339u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, player);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3224606339u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					NeckSpinRandomPlayerClientRpc(player);
				}
			}
		}

		[ClientRpc]
		public void NeckSpinRandomPlayerClientRpc(int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1671800337u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1671800337u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded && Misc.isPlayerLocal(playerId))
				{
					NeckSpin.SpinNeck();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EggBootsServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1807548886u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1807548886u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggBootsClientRpc(player);
				}
			}
		}

		[ClientRpc]
		public void EggBootsClientRpc(int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2159218070u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2159218070u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if ((Object)(object)StartOfRound.Instance.allPlayerScripts[playerId] == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					EggBoots.eggBootsEnabled = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EggBootsAllServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2123692491u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2123692491u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggBootsAllClientRpc();
				}
			}
		}

		[ClientRpc]
		public void EggBootsAllClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4259756343u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 4259756343u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggBoots.eggBootsEnabled = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void spawnExplodeEggServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1520326880u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1520326880u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggBoots.SpawnAndExplodeEgg(player);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EggBootsTwoServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(818694272u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 818694272u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggBootsTwoClientRpc(player);
				}
			}
		}

		[ClientRpc]
		public void EggBootsTwoClientRpc(int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(785906226u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 785906226u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggBoots.eggBootsEnabled = true;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void spawnExplodeEggTwoServerRpc(int player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3086860203u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, player);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3086860203u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EggBoots.SpawnAndExplodeEgg(player);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RandomStoreItemServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3278899816u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3278899816u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					RandomStoreItem.SpawnItem(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RandomStoreItemsServerRPC(int playerID, int totalItems)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4070546234u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				BytePacker.WriteValueBitPacked(val, totalItems);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 4070546234u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					RandomGreatStoreItem.SpawnItem(playerID, totalItems);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ItemSwapServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(269778369u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 269778369u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ItemSwapClientRPC();
				}
			}
		}

		[ClientRpc]
		public void ItemSwapClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2278535945u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2278535945u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
			PlayerControllerB randomAlivePlayer2 = Misc.GetRandomAlivePlayer();
			if (getValidPlayers().Count != 1)
			{
				while ((Object)(object)randomAlivePlayer == (Object)(object)randomAlivePlayer2)
				{
					randomAlivePlayer = Misc.GetRandomAlivePlayer();
					randomAlivePlayer2 = Misc.GetRandomAlivePlayer();
				}
				ItemSwap.itemSwap(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomAlivePlayer), Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomAlivePlayer2));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void GoldenTouchServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1518082378u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1518082378u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					int num = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer());
					int randomItem = GoldenTouch.GetRandomItem(num);
					GoldenTouchClientRPC(num, randomItem);
				}
			}
		}

		[ClientRpc]
		public void GoldenTouchClientRPC(int playerID, int itemSlot)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(944189951u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, playerID);
				BytePacker.WriteValueBitPacked(val, itemSlot);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 944189951u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerID);
			if (!((Object)(object)playerByUserID == (Object)null))
			{
				if (itemSlot > playerByUserID.ItemSlots.Length)
				{
					itemSlot = playerByUserID.ItemSlots.Length - 1;
				}
				if (itemSlot < 0)
				{
					itemSlot = 0;
				}
				GrabbableObject val3 = playerByUserID.ItemSlots[itemSlot];
				if (!((Object)(object)val3 == (Object)null))
				{
					val3.SetScrapValue(val3.scrapValue * 2);
					((Component)val3).GetComponentInChildren<ScanNodeProperties>().scrapValue = val3.scrapValue;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void LightBurdenServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1132514493u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1132514493u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LightBurdenClientRPC();
				}
			}
		}

		[ClientRpc]
		public void LightBurdenClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1050435668u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1050435668u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					LightBurden.lessenWeight(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ItemDuplicatorServerRPC(int playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3067940367u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, playerID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3067940367u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ItemDuplicator.duplicateItems(playerID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BatteryDrainServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(772901213u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 772901213u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BatteryDrainClientRPC();
				}
			}
		}

		[ClientRpc]
		public void BatteryDrainClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1243936304u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1243936304u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BatteryDrain.removeCharge(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void HeavyBurdenServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3149579903u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3149579903u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HeavyBurdenClientRPC();
				}
			}
		}

		[ClientRpc]
		public void HeavyBurdenClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1755114273u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1755114273u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HeavyBurden.increaseWeight(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void DrunkServerRPC(int userID, bool All = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a4: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1795889364u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref All, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1795889364u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					DrunkClientRPC(userID, All);
				}
			}
		}

		[ClientRpc]
		public void DrunkClientRPC(int userID, bool All)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00a4: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1467089812u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref All, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1467089812u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (All)
				{
					DrunkForAll.startDrinking(userID);
				}
				else
				{
					Drunk.startDrinking(userID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RerollServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3687388333u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3687388333u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Reroll.DiceScrap(userID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnCustomDieServerRPC(int userID, string effectName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_009b: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1161080782u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				bool flag = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1161080782u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				Reroll.DiceScrapWithEffect(userID, effectName);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RerollAllServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3084187454u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3084187454u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RerollAllClientRPC();
				}
			}
		}

		[ClientRpc]
		public void RerollAllClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1082877690u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1082877690u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RerollServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void setDiceEffectServerRPC(NetworkObjectReference reference, string effectName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_00a3: 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_011a: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1258713014u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref reference, default(ForNetworkSerializable));
				bool flag = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1258713014u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				setDiceEffectClientRPC(reference, effectName);
			}
		}

		[ClientRpc]
		public void setDiceEffectClientRPC(NetworkObjectReference reference, string effectName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_00a3: 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_011a: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2367606725u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref reference, default(ForNetworkSerializable));
				bool flag = effectName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(effectName, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2367606725u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			string effectName2 = effectName;
			NetworkObject val3 = default(NetworkObject);
			if (((NetworkObjectReference)(ref reference)).TryGet(ref val3, (NetworkManager)null))
			{
				IEffect nextEffect = DieBehaviour.AllEffects.Where((IEffect x) => x.Name == effectName2).First();
				((Component)val3).gameObject.GetComponent<DieBehaviour>().nextEffect = nextEffect;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AnythingGrenadeServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(425676860u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 425676860u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AnythingGrenade.Grenade(userID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TarotServerRPC(int userID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2712328859u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2712328859u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TarotCards.TarotScrap(userID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnGhostsServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(779827454u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 779827454u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Ghosts.SpawnGhosts();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnNutcrackerOutsideServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3712082155u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3712082155u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					NutcrackerOutside.SpawnOutsideNutcracker();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void GiveAllDiceServerRPC(int userID, int dice)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(238328387u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					BytePacker.WriteValueBitPacked(val, dice);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 238328387u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GiveAllDice.DiceScrap(userID);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doOxydePenaltyServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4139743480u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 4139743480u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					OxydePenalty.doPenalty();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void doPenaltyServerRPC(int amount)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1544793343u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, amount);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1544793343u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					NavMeshPenalty.doPenalty(amount);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpecialDetonateServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3247726588u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3247726588u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (StartOfRound.Instance != null && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
			{
				List<PlayerControllerB> list = new List<PlayerControllerB>();
				list = getValidPlayers();
				if (list.Count != 0)
				{
					PlayerControllerB value = list[Random.Range(0, list.Count)];
					SpecialDetonatePlayerClientRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, value));
				}
			}
		}

		[ClientRpc]
		public void SpecialDetonatePlayerClientRPC(int clientID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1615881557u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, clientID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1615881557u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
			{
				PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[clientID];
				if (Misc.isPlayerLocal(clientID) && Misc.IsPlayerAliveAndControlled(val3))
				{
					MysteryDice.sounds.TryGetValue("MineTrigger", out var value);
					AudioSource.PlayClipAtPoint(value, ((Component)val3).transform.position);
					((MonoBehaviour)this).StartCoroutine(SpawnExplosionAfterSFX(((Component)val3).transform.position, 3, 10, 70, 10));
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void GalDetonateServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2123193542u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2123193542u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (StartOfRound.Instance != null && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					GalDetonatePlayerClientRPC();
				}
			}
		}

		[ClientRpc]
		public void GalDetonatePlayerClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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_0130: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2102077482u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2102077482u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded || GalAI.Instances.Count == 0)
			{
				return;
			}
			foreach (GalAI instance in GalAI.Instances)
			{
				MysteryDice.sounds.TryGetValue("MineTrigger", out var value);
				AudioSource.PlayClipAtPoint(value, ((Component)instance).transform.position);
				((MonoBehaviour)this).StartCoroutine(SpawnExplosionAfterSFX(((Component)instance).transform.position, 3, 10, 70, 10));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AllFlyServerRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3715261571u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3715261571u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					allFlyClientRPC();
				}
			}
		}

		[ClientRpc]
		public void allFlyClientRPC()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(990091644u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 990091644u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Fly.CanFly = true;
					Misc.SafeTipMessage("You can fly now!", "Double Tap Space to Fly!");
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Expected O, but got Unknown
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Expected O, but got Unknown
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Expected O, but got Unknown
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Expected O, but got Unknown
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Expected O, but got Unknown
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Expected O, but got Unknown
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Expected O, but got Unknown
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Expected O, but got Unknown
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Expected O, but got Unknown
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Expected O, but got Unknown
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_0515: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Expected O, but got Unknown
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Expected O, but got Unknown
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Expected O, but got Unknown
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Expected O, but got Unknown
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Expected O, but got Unknown
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Expected O, but got Unknown
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Expected O, but got Unknown
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Expected O, but got Unknown
			//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0604: Expected O, but got Unknown
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_0620: Expected O, but got Unknown
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Expected O, but got Unknown
			//IL_0649: Unknown result type (might be due to invalid IL or missing references)
			//IL_0658: Expected O, but got Unknown
			//IL_0665: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Expected O, but got Unknown
			//IL_0681: Unknown result type (might be due to invalid IL or missing references)
			//IL_0690: Expected O, but got Unknown
			//IL_069d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Expected O, but got Unknown
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c8: Expected O, but got Unknown
			//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e4: Expected O, but got Unknown
			//IL_06f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0700: Expected O, but got Unknown
			//IL_070d: Unknown result type (might be due to invalid IL or missing references)
			//IL_071c: Expected O, but got Unknown
			//IL_0729: Unknown result type (might be due to invalid IL or missing references)
			//IL_0738: Expected O, but got Unknown
			//IL_0745: Unknown result type (might be due to invalid IL or missing references)
			//IL_0754: Expected O, but got Unknown
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			//IL_0770: Expected O, but got Unknown
			//IL_077d: Unknown result type (might be due to invalid IL or missing references)
			//IL_078c: Expected O, but got Unknown
			//IL_0799: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Expected O, but got Unknown
			//IL_07b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c4: Expected O, but got Unknown
			//IL_07d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e0: Expected O, but got Unknown
			//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fc: Expected O, but got Unknown
			//IL_0809: Unknown result type (might be due to invalid IL or missing references)
			//IL_0818: Expected O, but got Unknown
			//IL_0825: Unknown result type (might be due to invalid IL or missing references)
			//IL_0834: Expected O, but got Unknown
			//IL_0841: Unknown result type (might be due to invalid IL or missing references)
			//IL_0850: Expected O, but got Unknown
			//IL_085d: Unknown result type (might be due to invalid IL or missing references)
			//IL_086c: Expected O, but got Unknown
			//IL_0879: Unknown result type (might be due to invalid IL or missing references)
			//IL_0888: Expected O, but got Unknown
			//IL_0895: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a4: Expected O, but got Unknown
			//IL_08b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c0: Expected O, but got Unknown
			//IL_08cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_08dc: Expected O, but got Unknown
			//IL_08e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f8: Expected O, but got Unknown
			//IL_0905: Unknown result type (might be due to invalid IL or missing references)
			//IL_0914: Expected O, but got Unknown
			//IL_0921: Unknown result type (might be due to invalid IL or missing references)
			//IL_0930: Expected O, but got Unknown
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_094c: Expected O, but got Unknown
			//IL_0959: Unknown result type (might be due to invalid IL or missing references)
			//IL_0968: Expected O, but got Unknown
			//IL_0975: Unknown result type (might be due to invalid IL or missing references)
			//IL_0984: Expected O, but got Unknown
			//IL_0991: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a0: Expected O, but got Unknown
			//IL_09ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bc: Expected O, but got Unknown
			//IL_09c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d8: Expected O, but got Unknown
			//IL_09e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f4: Expected O, but got Unknown
			//IL_0a01: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a10: Expected O, but got Unknown
			//IL_0a1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2c: Expected O, but got Unknown
			//IL_0a39: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a48: Expected O, but got Unknown
			//IL_0a55: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a64: Expected O, but got Unknown
			//IL_0a71: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a80: Expected O, but got Unknown
			//IL_0a8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9c: Expected O, but got Unknown
			//IL_0aa9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab8: Expected O, but got Unknown
			//IL_0ac5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad4: Expected O, but got Unknown
			//IL_0ae1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af0: Expected O, but got Unknown
			//IL_0afd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0c: Expected O, but got Unknown
			//IL_0b19: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b28: Expected O, but got Unknown
			//IL_0b35: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b44: Expected O, but got Unknown
			//IL_0b51: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b60: Expected O, but got Unknown
			//IL_0b6d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b7c: Expected O, but got Unknown
			//IL_0b89: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b98: Expected O, but got Unknown
			//IL_0ba5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb4: Expected O, but got Unknown
			//IL_0bc1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd0: Expected O, but got Unknown
			//IL_0bdd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bec: Expected O, but got Unknown
			//IL_0bf9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c08: Expected O, but got Unknown
			//IL_0c15: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c24: Expected O, but got Unknown
			//IL_0c31: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c40: Expected O, but got Unknown
			//IL_0c4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c5c: Expected O, but got Unknown
			//IL_0c69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c78: Expected O, but got Unknown
			//IL_0c85: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c94: Expected O, but got Unknown
			//IL_0ca1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb0: Expected O, but got Unknown
			//IL_0cbd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ccc: Expected O, but got Unknown
			//IL_0cd9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce8: Expected O, but got Unknown
			//IL_0cf5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d04: Expected O, but got Unknown
			//IL_0d11: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d20: Expected O, but got Unknown
			//IL_0d2d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d3c: Expected O, but got Unknown
			//IL_0d49: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d58: Expected O, but got Unknown
			//IL_0d65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d74: Expected O, but got Unknown
			//IL_0d81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d90: Expected O, but got Unknown
			//IL_0d9d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dac: Expected O, but got Unknown
			//IL_0db9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc8: Expected O, but got Unknown
			//IL_0dd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de4: Expected O, but got Unknown
			//IL_0df1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e00: Expected O, but got Unknown
			//IL_0e0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e1c: Expected O, but got Unknown
			//IL_0e29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e38: Expected O, but got Unknown
			//IL_0e45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e54: Expected O, but got Unknown
			//IL_0e61: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e70: Expected O, but got Unknown
			//IL_0e7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e8c: Expected O, but got Unknown
			//IL_0e99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea8: Expected O, but got Unknown
			//IL_0eb5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ec4: Expected O, but got Unknown
			//IL_0ed1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ee0: Expected O, but got Unknown
			//IL_0eed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0efc: Expected O, but got Unknown
			//IL_0f09: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f18: Expected O, but got Unknown
			//IL_0f25: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f34: Expected O, but got Unknown
			//IL_0f41: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f50: Expected O, but got Unknown
			//IL_0f5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f6c: Expected O, but got Unknown
			//IL_0f79: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f88: Expected O, but got Unknown
			//IL_0f95: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fa4: Expected O, but got Unknown
			//IL_0fb1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc0: Expected O, but got Unknown
			//IL_0fcd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fdc: Expected O, but got Unknown
			//IL_0fe9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ff8: Expected O, but got Unknown
			//IL_1005: Unknown result type (might be due to invalid IL or missing references)
			//IL_1014: Expected O, but got Unknown
			//IL_1021: Unknown result type (might be due to invalid IL or missing references)
			//IL_1030: Expected O, but got Unknown
			//IL_103d: Unknown result type (might be due to invalid IL or missing references)
			//IL_104c: Expected O, but got Unknown
			//IL_1059: Unknown result type (might be due to invalid IL or missing references)
			//IL_1068: Expected O, but got Unknown
			//IL_1075: Unknown result type (might be due to invalid IL or missing references)
			//IL_1084: Expected O, but got Unknown
			//IL_1091: Unknown result type (might be due to invalid IL or missing references)
			//IL_10a0: Expected O, but got Unknown
			//IL_10ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_10bc: Expected O, but got Unknown
			//IL_10c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_10d8: Expected O, but got Unknown
			//IL_10e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_10f4: Expected O, but got Unknown
			//IL_1101: Unknown result type (might be due to invalid IL or missing references)
			//IL_1110: Expected O, but got Unknown
			//IL_111d: Unknown result type (might be due to invalid IL or missing references)
			//IL_112c: Expected O, but got Unknown
			//IL_1139: Unknown result type (might be due to invalid IL or missing references)
			//IL_1148: Expected O, but got Unknown
			//IL_1155: Unknown result type (might be due to invalid IL or missing references)
			//IL_1164: Expected O, but got Unknown
			//IL_1171: Unknown result type (might be due to invalid IL or missing references)
			//IL_1180: Expected O, but got Unknown
			//IL_118d: Unknown result type (might be due to invalid IL or missing references)
			//IL_119c: Expected O, but got Unknown
			//IL_11a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_11b8: Expected O, but got Unknown
			//IL_11c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_11d4: Expected O, but got Unknown
			//IL_11e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_11f0: Expected O, but got Unknown
			//IL_11fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_120c: Expected O, but got Unknown
			//IL_1219: Unknown result type (might be due to invalid IL or missing references)
			//IL_1228: Expected O, but got Unknown
			//IL_1235: Unknown result type (might be due to invalid IL or missing references)
			//IL_1244: Expected O, but got Unknown
			//IL_1251: Unknown result type (might be due to invalid IL or missing references)
			//IL_1260: Expected O, but got Unknown
			//IL_126d: Unknown result type (might be due to invalid IL or missing references)
			//IL_127c: Expected O, but got Unknown
			//IL_1289: Unknown result type (might be due to invalid IL or missing references)
			//IL_1298: Expected O, but got Unknown
			//IL_12a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_12b4: Expected O, but got Unknown
			//IL_12c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_12d0: Expected O, but got Unknown
			//IL_12dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_12ec: Expected O, but got Unknown
			//IL_12f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1308: Expected O, but got Unknown
			//IL_1315: Unknown result type (might be due to invalid IL or missing references)
			//IL_1324: Expected O, but got Unknown
			//IL_1331: Unknown result type (might be due to invalid IL or missing references)
			//IL_1340: Expected O, but got Unknown
			//IL_134d: Unknown result type (might be due to invalid IL or missing references)
			//IL_135c: Expected O, but got Unknown
			//IL_1369: Unknown result type (might be due to invalid IL or missing references)
			//IL_1378: Expected O, but got Unknown
			//IL_1385: Unknown result type (might be due to invalid IL or missing references)
			//IL_1394: Expected O, but got Unknown
			//IL_13a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_13b0: Expected O, but got Unknown
			//IL_13bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_13cc: Expected O, but got Unknown
			//IL_13d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_13e8: Expected O, but got Unknown
			//IL_13f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1404: Expected O, but got Unknown
			//IL_1411: Unknown result type (might be due to invalid IL or missing references)
			//IL_1420: Expected O, but got Unknown
			//IL_142d: Unknown result type (might be due to invalid IL or missing references)
			//IL_143c: Expected O, but got Unknown
			//IL_1449: Unknown result type (might be due to invalid IL or missing references)
			//IL_1458: Expected O, but got Unknown
			//IL_1465: Unknown result type (might be due to invalid IL or missing references)
			//IL_1474: Expected O, but got Unknown
			//IL_1481: Unknown result type (might be due to invalid IL or missing references)
			//IL_1490: Expected O, but got Unknown
			//IL_149d: Unknown result type (might be due to invalid IL or missing references)
			//IL_14ac: Expected O, but got Unknown
			//IL_14b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_14c8: Expected O, but got Unknown
			//IL_14d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_14e4: Expected O, but got Unknown
			//IL_14f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1500: Expected O, but got Unknown
			//IL_150d: Unknown result type (might be due to invalid IL or missing references)
			//IL_151c: Expected O, but got Unknown
			//IL_1529: Unknown result type (might be due to invalid IL or missing references)
			//IL_1538: Expected O, but got Unknown
			//IL_1545: Unknown result type (might be due to invalid IL or missing references)
			//IL_1554: Expected O, but got Unknown
			//IL_1561: Unknown result type (might be due to invalid IL or missing references)
			//IL_1570: Expected O, but got Unknown
			//IL_157d: Unknown result type (might be due to invalid IL or missing references)
			//IL_158c: Expected O, but got Unknown
			//IL_1599: Unknown result type (might be due to invalid IL or missing references)
			//IL_15a8: Expected O, but got Unknown
			//IL_15b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_15c4: Expected O, but got Unknown
			//IL_15d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_15e0: Expected O, but got Unknown
			//IL_15ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_15fc: Expected O, but got Unknown
			//IL_1609: Unknown result type (might be due to invalid IL or missing references)
			//IL_1618: Expected O, but got Unknown
			//IL_1625: Unknown result type (might be due to invalid IL or missing references)
			//IL_1634: Expected O, but got Unknown
			//IL_1641: Unknown result type (might be due to invalid IL or missing references)
			//IL_1650: Expected O, but got Unknown
			//IL_165d: Unknown result type (might be due to invalid IL or missing references)
			//IL_166c: Expected O, but got Unknown
			//IL_1679: Unknown result type (might be due to invalid IL or missing references)
			//IL_1688: Expected O, but got Unknown
			//IL_1695: Unknown result type (might be due to invalid IL or missing references)
			//IL_16a4: Expected O, but got Unknown
			//IL_16b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_16c0: Expected O, but got Unknown
			//IL_16cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_16dc: Expected O, but got Unknown
			//IL_16e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_16f8: Expected O, but got Unknown
			//IL_1705: Unknown result type (might be due to invalid IL or missing references)
			//IL_1714: Expected O, but got Unknown
			//IL_1721: Unknown result type (might be due to invalid IL or missing references)
			//IL_1730: Expected O, but got Unknown
			//IL_173d: Unknown result type (might be due to invalid IL or missing references)
			//IL_174c: Expected O, but got Unknown
			//IL_1759: Unknown result type (might be due to invalid IL or missing references)
			//IL_1768: Expected O, but got Unknown
			//IL_1775: Unknown result type (might be due to invalid IL or missing references)
			//IL_1784: Expected O, but got Unknown
			//IL_1791: Unknown result type (might be due to invalid IL or missing references)
			//IL_17a0: Expected O, but got Unknown
			//IL_17ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_17bc: Expected O, but got Unknown
			//IL_17c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_17d8: Expected O, but got Unknown
			//IL_17e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_17f4: Expected O, but got Unknown
			//IL_1801: Unknown result type (might be due to invalid IL or missing references)
			//IL_1810: Expected O, but got Unknown
			//IL_181d: Unknown result type (might be due to invalid IL or missing references)
			//IL_182c: Expected O, but got Unknown
			//IL_1839: Unknown result type (might be due to invalid IL or missing references)
			//IL_1848: Expected O, but got Unknown
			//IL_1855: Unknown result type (might be due to invalid IL or missing references)
			//IL_1864: Expected O, but got Unknown
			//IL_1871: Unknown result type (might be due to invalid IL or missing references)
			//IL_1880: Expected O, but got Unknown
			//IL_188d: Unknown result type (might be due to invalid IL or missing references)
			//IL_189c: Expected O, but got Unknown
			//IL_18a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_18b8: Expected O, but got Unknown
			//IL_18c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_18d4: Expected O, but got Unknown
			//IL_18e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_18f0: Expected O, but got Unknown
			//IL_18fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_190c: Expected O, but got Unknown
			//IL_1919: Unknown result type (might be due to invalid IL or missing references)
			//IL_1928: Expected O, but got Unknown
			//IL_1935: Unknown result type (might be due to invalid IL or missing references)
			//IL_1944: Expected O, but got Unknown
			//IL_1951: Unknown result type (might be due to invalid IL or missing references)
			//IL_1960: Expected O, but got Unknown
			//IL_196d: Unknown result type (might be due to invalid IL or missing references)
			//IL_197c: Expected O, but got Unknown
			//IL_1989: Unknown result type (might be due to invalid IL or missing references)
			//IL_1998: Expected O, but got Unknown
			//IL_19a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_19b4: Expected O, but got Unknown
			//IL_19c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_19d0: Expected O, but got Unknown
			//IL_19dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_19ec: Expected O, but got Unknown
			//IL_19f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a08: Expected O, but got Unknown
			//IL_1a15: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a24: Expected O, but got Unknown
			//IL_1a31: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a40: Expected O, but got Unknown
			//IL_1a4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a5c: Expected O, but got Unknown
			//IL_1a69: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a78: Expected O, but got Unknown
			//IL_1a85: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a94: Expected O, but got Unknown
			//IL_1aa1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ab0: Expected O, but got Unknown
			//IL_1abd: Unknown result type (might be due to invalid IL or missing references)
			//IL_1acc: Expected O, but got Unknown
			//IL_1ad9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ae8: Expected O, but got Unknown
			//IL_1af5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b04: Expected O, but got Unknown
			//IL_1b11: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b20: Expected O, but got Unknown
			//IL_1b2d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b3c: Expected O, but got Unknown
			//IL_1b49: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b58: Expected O, but got Unknown
			//IL_1b65: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b74: Expected O, but got Unknown
			//IL_1b81: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b90: Expected O, but got Unknown
			//IL_1b9d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bac: Expected O, but got Unknown
			//IL_1bb9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bc8: Expected O, but got Unknown
			//IL_1bd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1be4: Expected O, but got Unknown
			//IL_1bf1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c00: Expected O, but got Unknown
			//IL_1c0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c1c: Expected O, but got Unknown
			//IL_1c29: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c38: Expected O, but got Unknown
			//IL_1c45: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c54: Expected O, but got Unknown
			//IL_1c61: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c70: Expected O, but got Unknown
			//IL_1c7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c8c: Expected O, but got Unknown
			//IL_1c99: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ca8: Expected O, but got Unknown
			//IL_1cb5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1cc4: Expected O, but got Unknown
			//IL_1cd1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ce0: Expected O, but got Unknown
			//IL_1ced: Unknown result type (might be due to invalid IL or missing references)
			//IL_1cfc: Expected O, but got Unknown
			//IL_1d09: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d18: Expected O, but got Unknown
			//IL_1d25: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d34: Expected O, but got Unknown
			//IL_1d41: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d50: Expected O, but got Unknown
			//IL_1d5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d6c: Expected O, but got Unknown
			//IL_1d79: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d88: Expected O, but got Unknown
			//IL_1d95: Unknown result type (might be due to invalid IL or missing references)
			//IL_1da4: Expected O, but got Unknown
			//IL_1db1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1dc0: Expected O, but got Unknown
			//IL_1dcd: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ddc: Expected O, but got Unknown
			//IL_1de9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1df8: Expected O, but got Unknown
			//IL_1e05: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e14: Expected O, but got Unknown
			//IL_1e21: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e30: Expected O, but got Unknown
			//IL_1e3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e4c: Expected O, but got Unknown
			//IL_1e59: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e68: Expected O, but got Unknown
			//IL_1e75: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e84: Expected O, but got Unknown
			//IL_1e91: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ea0: Expected O, but got Unknown
			//IL_1ead: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ebc: Expected O, but got Unknown
			//IL_1ec9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ed8: Expected O, but got Unknown
			//IL_1ee5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ef4: Expected O, but got Unknown
			//IL_1f01: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f10: Expected O, but got Unknown
			//IL_1f1d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f2c: Expected O, but got Unknown
			//IL_1f39: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f48: Expected O, but got Unknown
			//IL_1f55: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f64: Expected O, but got Unknown
			//IL_1f71: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f80: Expected O, but got Unknown
			//IL_1f8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f9c: Expected O, but got Unknown
			//IL_1fa9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1fb8: Expected O, but got Unknown
			//IL_1fc5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1fd4: Expected O, but got Unknown
			//IL_1fe1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ff0: Expected O, but got Unknown
			//IL_1ffd: Unknown result type (might be due to invalid IL or missing references)
			//IL_200c: Expected O, but got Unknown
			//IL_2019: Unknown result type (might be due to invalid IL or missing references)
			//IL_2028: Expected O, but got Unknown
			//IL_2035: Unknown result type (might be due to invalid IL or missing references)
			//IL_2044: Expected O, but got Unknown
			//IL_2051: Unknown result type (might be due to invalid IL or missing references)
			//IL_2060: Expected O, but got Unknown
			//IL_206d: Unknown result type (might be due to invalid IL or missing references)
			//IL_207c: Expected O, but got Unknown
			//IL_2089: Unknown result type (might be due to invalid IL or missing references)
			//IL_2098: Expected O, but got Unknown
			//IL_20a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_20b4: Expected O, but got Unknown
			//IL_20c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_20d0: Expected O, but got Unknown
			//IL_20dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_20ec: Expected O, but got Unknown
			//IL_20f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_2108: Expected O, but got Unknown
			//IL_2115: Unknown result type (might be due to invalid IL or missing references)
			//IL_2124: Expected O, but got Unknown
			//IL_2131: Unknown result type (might be due to invalid IL or missing references)
			//IL_2140: Expected O, but got Unknown
			//IL_214d: Unknown result type (might be due to invalid IL or missing references)
			//IL_215c: Expected O, but got Unknown
			//IL_2169: Unknown result type (might be due to invalid IL or missing references)
			//IL_2178: Expected O, but got Unknown
			//IL_2185: Unknown result type (might be due to invalid IL or missing references)
			//IL_2194: Expected O, but got Unknown
			//IL_21a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_21b0: Expected O, but got Unknown
			//IL_21bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_21cc: Expected O, but got Unknown
			//IL_21d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_21e8: Expected O, but got Unknown
			//IL_21f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_2204: Expected O, but got Unknown
			//IL_2211: Unknown result type (might be due to invalid IL or missing references)
			//IL_2220: Expected O, but got Unknown
			//IL_222d: Unknown result type (might be due to invalid IL or missing references)
			//IL_223c: Expected O, but got Unknown
			//IL_2249: Unknown result type (might be due to invalid IL or missing references)
			//IL_2258: Expected O, but got Unknown
			//IL_2265: Unknown result type (might be due to invalid IL or missing references)
			//IL_2274: Expected O, but got Unknown
			//IL_2281: Unknown result type (might be due to invalid IL or missing references)
			//IL_2290: Expected O, but got Unknown
			//IL_229d: Unknown result type (might be due to invalid IL or missing references)
			//IL_22ac: Expected O, but got Unknown
			//IL_22b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_22c8: Expected O, but got Unknown
			//IL_22d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_22e4: Expected O, but got Unknown
			//IL_22f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_2300: Expected O, but got Unknown
			//IL_230d: Unknown result type (might be due to invalid IL or missing references)
			//IL_231c: Expected O, but got Unknown
			//IL_2329: Unknown result type (might be due to invalid IL or missing references)
			//IL_2338: Expected O, but got Unknown
			//IL_2345: Unknown result type (might be due to invalid IL or missing references)
			//IL_2354: Expected O, but got Unknown
			//IL_2361: Unknown result type (might be due to invalid IL or missing references)
			//IL_2370: Expected O, but got Unknown
			//IL_237d: Unknown result type (might be due to invalid IL or missing references)
			//IL_238c: Expected O, but got Unknown
			//IL_2399: Unknown result type (might be due to invalid IL or missing references)
			//IL_23a8: Expected O, but got Unknown
			//IL_23b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_23c4: Expected O, but got Unknown
			//IL_23d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_23e0: Expected O, but got Unknown
			//IL_23ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_23fc: Expected O, but got Unknown
			//IL_2409: Unknown result type (might be due to invalid IL or missing references)
			//IL_2418: Expected O, but got Unknown
			//IL_2425: Unknown result type (might be due to invalid IL or missing references)
			//IL_2434: Expected O, but got Unknown
			//IL_2441: Unknown result type (might be due to invalid IL or missing references)
			//IL_2450: Expected O, but got Unknown
			//IL_245d: Unknown result type (might be due to invalid IL or missing references)
			//IL_246c: Expected O, but got Unknown
			//IL_2479: Unknown result type (might be due to invalid IL or missing references)
			//IL_2488: Expected O, but got Unknown
			//IL_2495: Unknown result type (might be due to invalid IL or missing references)
			//IL_24a4: Expected O, but got Unknown
			//IL_24b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_24c0: Expected O, but got Unknown
			//IL_24cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_24dc: Expected O, but got Unknown
			//IL_24e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_24f8: Expected O, but got Unknown
			//IL_2505: Unknown result type (might be due to invalid IL or missing references)
			//IL_2514: Expected O, but got Unknown
			//IL_2521: Unknown result type (might be due to invalid IL or missing references)
			//IL_2530: Expected O, but got Unknown
			//IL_253d: Unknown result type (might be due to invalid IL or missing references)
			//IL_254c: Expected O, but got Unknown
			//IL_2559: Unknown result type (might be due to invalid IL or missing references)
			//IL_2568: Expected O, but got Unknown
			//IL_2575: Unknown result type (might be due to invalid IL or missing references)
			//IL_2584: Expected O, but got Unknown
			//IL_2591: Unknown result type (might be due to invalid IL or missing references)
			//IL_25a0: Expected O, but got Unknown
			//IL_25ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_25bc: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1906074443u, new RpcReceiveHandler(__rpc_handler_1906074443), "AddControllerServerRPC");
			((NetworkBehaviour)this).__registerRpc(2717902209u, new RpcReceiveHandler(__rpc_handler_2717902209), "AddControllerClientRPC");
			((NetworkBehaviour)this).__registerRpc(2696892243u, new RpcReceiveHandler(__rpc_handler_2696892243), "LogEffectsToOwnerServerRPC");
			((NetworkBehaviour)this).__registerRpc(1737623636u, new RpcReceiveHandler(__rpc_handler_1737623636), "LogEffectsToHostClientRPC");
			((NetworkBehaviour)this).__registerRpc(1307310058u, new RpcReceiveHandler(__rpc_handler_1307310058), "LogEffectsToSlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(1822397394u, new RpcReceiveHandler(__rpc_handler_1822397394), "LogEffectsToEveryoneClientRPC");
			((NetworkBehaviour)this).__registerRpc(1360560965u, new RpcReceiveHandler(__rpc_handler_1360560965), "RequestEffectConfigServerRPC");
			((NetworkBehaviour)this).__registerRpc(4142878533u, new RpcReceiveHandler(__rpc_handler_4142878533), "SendConfigClientRPC");
			((NetworkBehaviour)this).__registerRpc(79093998u, new RpcReceiveHandler(__rpc_handler_79093998), "RequestConfigSyncServerRPC");
			((NetworkBehaviour)this).__registerRpc(3630596093u, new RpcReceiveHandler(__rpc_handler_3630596093), "SendConfigsClientRPC");
			((NetworkBehaviour)this).__registerRpc(3353804004u, new RpcReceiveHandler(__rpc_handler_3353804004), "RequestSyncCursedServerRPC");
			((NetworkBehaviour)this).__registerRpc(1002459835u, new RpcReceiveHandler(__rpc_handler_1002459835), "SyncCursedPlayersClientRpc");
			((NetworkBehaviour)this).__registerRpc(324328356u, new RpcReceiveHandler(__rpc_handler_324328356), "killPlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(515572243u, new RpcReceiveHandler(__rpc_handler_515572243), "killPlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(275668481u, new RpcReceiveHandler(__rpc_handler_275668481), "FixPlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(4005833429u, new RpcReceiveHandler(__rpc_handler_4005833429), "MoveTrapServerRpc");
			((NetworkBehaviour)this).__registerRpc(3424035373u, new RpcReceiveHandler(__rpc_handler_3424035373), "rollEffectRandomPlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(2557683131u, new RpcReceiveHandler(__rpc_handler_2557683131), "ProcessRollEffectClientRPC");
			((NetworkBehaviour)this).__registerRpc(26955910u, new RpcReceiveHandler(__rpc_handler_26955910), "QueueRandomDiceEffectServerRPC");
			((NetworkBehaviour)this).__registerRpc(1559418665u, new RpcReceiveHandler(__rpc_handler_1559418665), "QueueSpecificDiceEffectServerRPC");
			((NetworkBehaviour)this).__registerRpc(775413581u, new RpcReceiveHandler(__rpc_handler_775413581), "QueueSelectTypeServerRPC");
			((NetworkBehaviour)this).__registerRpc(2898041828u, new RpcReceiveHandler(__rpc_handler_2898041828), "NemosplosionServerRPC");
			((NetworkBehaviour)this).__registerRpc(2543568230u, new RpcReceiveHandler(__rpc_handler_2543568230), "UnkillableServerRpc");
			((NetworkBehaviour)this).__registerRpc(3338645896u, new RpcReceiveHandler(__rpc_handler_3338645896), "removeKillServerRPC");
			((NetworkBehaviour)this).__registerRpc(2450559096u, new RpcReceiveHandler(__rpc_handler_2450559096), "removeKillClientRPC");
			((NetworkBehaviour)this).__registerRpc(1037540588u, new RpcReceiveHandler(__rpc_handler_1037540588), "AdServerRPC");
			((NetworkBehaviour)this).__registerRpc(1632183355u, new RpcReceiveHandler(__rpc_handler_1632183355), "AdClientRPC");
			((NetworkBehaviour)this).__registerRpc(4103428810u, new RpcReceiveHandler(__rpc_handler_4103428810), "TriggerManyAdsServerRpc");
			((NetworkBehaviour)this).__registerRpc(433094646u, new RpcReceiveHandler(__rpc_handler_433094646), "TriggerSelectAdsServerRpc");
			((NetworkBehaviour)this).__registerRpc(1369477639u, new RpcReceiveHandler(__rpc_handler_1369477639), "RandomAdItemServerRpc");
			((NetworkBehaviour)this).__registerRpc(1996097052u, new RpcReceiveHandler(__rpc_handler_1996097052), "RequestEmotesInRadiusServerRpc");
			((NetworkBehaviour)this).__registerRpc(2209572773u, new RpcReceiveHandler(__rpc_handler_2209572773), "PerformRandomEmoteClientRpc");
			((NetworkBehaviour)this).__registerRpc(1413525009u, new RpcReceiveHandler(__rpc_handler_1413525009), "setHealthServerRPC");
			((NetworkBehaviour)this).__registerRpc(405187854u, new RpcReceiveHandler(__rpc_handler_405187854), "setHealthClientRPC");
			((NetworkBehaviour)this).__registerRpc(4264730339u, new RpcReceiveHandler(__rpc_handler_4264730339), "SpawnSurroundedServerRPC");
			((NetworkBehaviour)this).__registerRpc(2614339007u, new RpcReceiveHandler(__rpc_handler_2614339007), "SpawnSurroundedSelectServerRPC");
			((NetworkBehaviour)this).__registerRpc(2456088190u, new RpcReceiveHandler(__rpc_handler_2456088190), "SpawnSurroundedTrapServerRPC");
			((NetworkBehaviour)this).__registerRpc(1227566611u, new RpcReceiveHandler(__rpc_handler_1227566611), "setSizeClientRPC");
			((NetworkBehaviour)this).__registerRpc(2881472247u, new RpcReceiveHandler(__rpc_handler_2881472247), "MatchSizeClientRPC");
			((NetworkBehaviour)this).__registerRpc(1580401083u, new RpcReceiveHandler(__rpc_handler_1580401083), "setDiceSizeClientRPC");
			((NetworkBehaviour)this).__registerRpc(2393095572u, new RpcReceiveHandler(__rpc_handler_2393095572), "removeShadowsClientRPC");
			((NetworkBehaviour)this).__registerRpc(2164475308u, new RpcReceiveHandler(__rpc_handler_2164475308), "spawnFlingerServerRPC");
			((NetworkBehaviour)this).__registerRpc(1091680114u, new RpcReceiveHandler(__rpc_handler_1091680114), "setHorseStuffServerRPC");
			((NetworkBehaviour)this).__registerRpc(1137837317u, new RpcReceiveHandler(__rpc_handler_1137837317), "setHorseStuffClientRPC");
			((NetworkBehaviour)this).__registerRpc(1535208873u, new RpcReceiveHandler(__rpc_handler_1535208873), "DelayedReactionServerRPC");
			((NetworkBehaviour)this).__registerRpc(3851315013u, new RpcReceiveHandler(__rpc_handler_3851315013), "DelayedReactionClientRPC");
			((NetworkBehaviour)this).__registerRpc(1097447221u, new RpcReceiveHandler(__rpc_handler_1097447221), "AlarmServerRPC");
			((NetworkBehaviour)this).__registerRpc(3450213494u, new RpcReceiveHandler(__rpc_handler_3450213494), "AlarmClientRPC");
			((NetworkBehaviour)this).__registerRpc(3393414643u, new RpcReceiveHandler(__rpc_handler_3393414643), "ShowAdMenuServerRPC");
			((NetworkBehaviour)this).__registerRpc(2183580584u, new RpcReceiveHandler(__rpc_handler_2183580584), "ShowAdMenuClientRPC");
			((NetworkBehaviour)this).__registerRpc(1121024086u, new RpcReceiveHandler(__rpc_handler_1121024086), "FreeCruiserServerRPC");
			((NetworkBehaviour)this).__registerRpc(866465074u, new RpcReceiveHandler(__rpc_handler_866465074), "DeleteThingServerRPC");
			((NetworkBehaviour)this).__registerRpc(1118192716u, new RpcReceiveHandler(__rpc_handler_1118192716), "OnStartRoundClientRPC");
			((NetworkBehaviour)this).__registerRpc(1471895020u, new RpcReceiveHandler(__rpc_handler_1471895020), "DetonateRandomPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(1224495368u, new RpcReceiveHandler(__rpc_handler_1224495368), "DoLizardServerRPC");
			((NetworkBehaviour)this).__registerRpc(3864594486u, new RpcReceiveHandler(__rpc_handler_3864594486), "ConfusionPlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(361427529u, new RpcReceiveHandler(__rpc_handler_361427529), "ConfusionPlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(698961352u, new RpcReceiveHandler(__rpc_handler_698961352), "OopsPlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(2884546173u, new RpcReceiveHandler(__rpc_handler_2884546173), "OopsPlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(3908042166u, new RpcReceiveHandler(__rpc_handler_3908042166), "DetonatePlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(3123714467u, new RpcReceiveHandler(__rpc_handler_3123714467), "ReviveAllPlayersServerRpc");
			((NetworkBehaviour)this).__registerRpc(954997453u, new RpcReceiveHandler(__rpc_handler_954997453), "ReviveAllPlayersClientRpc");
			((NetworkBehaviour)this).__registerRpc(67657836u, new RpcReceiveHandler(__rpc_handler_67657836), "fixRespawnClientRPC");
			((NetworkBehaviour)this).__registerRpc(3039924435u, new RpcReceiveHandler(__rpc_handler_3039924435), "reviveNextServerRPC");
			((NetworkBehaviour)this).__registerRpc(221188056u, new RpcReceiveHandler(__rpc_handler_221188056), "reviveChanceServerRPC");
			((NetworkBehaviour)this).__registerRpc(3347467633u, new RpcReceiveHandler(__rpc_handler_3347467633), "RevivePlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(3597900664u, new RpcReceiveHandler(__rpc_handler_3597900664), "RevivePlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(381327132u, new RpcReceiveHandler(__rpc_handler_381327132), "AddLifeAllServerRPC");
			((NetworkBehaviour)this).__registerRpc(1581190059u, new RpcReceiveHandler(__rpc_handler_1581190059), "AddLifeServerRPC");
			((NetworkBehaviour)this).__registerRpc(835406534u, new RpcReceiveHandler(__rpc_handler_835406534), "SendMessageServerRPC");
			((NetworkBehaviour)this).__registerRpc(29878885u, new RpcReceiveHandler(__rpc_handler_29878885), "SendMessageClientRPC");
			((NetworkBehaviour)this).__registerRpc(654414994u, new RpcReceiveHandler(__rpc_handler_654414994), "AddLifeClientRPC");
			((NetworkBehaviour)this).__registerRpc(4087975116u, new RpcReceiveHandler(__rpc_handler_4087975116), "TeleportInsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(2709139905u, new RpcReceiveHandler(__rpc_handler_2709139905), "TeleportInsideClientRPC");
			((NetworkBehaviour)this).__registerRpc(603695207u, new RpcReceiveHandler(__rpc_handler_603695207), "MartyrdomServerRPC");
			((NetworkBehaviour)this).__registerRpc(567713551u, new RpcReceiveHandler(__rpc_handler_567713551), "MartyrdomClientRPC");
			((NetworkBehaviour)this).__registerRpc(3858378172u, new RpcReceiveHandler(__rpc_handler_3858378172), "doMartyrdomServerRPC");
			((NetworkBehaviour)this).__registerRpc(2222788764u, new RpcReceiveHandler(__rpc_handler_2222788764), "TeleportToShipServerRPC");
			((NetworkBehaviour)this).__registerRpc(2386185210u, new RpcReceiveHandler(__rpc_handler_2386185210), "TeleportToShipClientRPC");
			((NetworkBehaviour)this).__registerRpc(1449390942u, new RpcReceiveHandler(__rpc_handler_1449390942), "despawnEnemyServerRpc");
			((NetworkBehaviour)this).__registerRpc(2480012683u, new RpcReceiveHandler(__rpc_handler_2480012683), "TeleportToPlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(114950063u, new RpcReceiveHandler(__rpc_handler_114950063), "TeleportToPlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(1165488094u, new RpcReceiveHandler(__rpc_handler_1165488094), "TeleportOrBringPlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(740943656u, new RpcReceiveHandler(__rpc_handler_740943656), "TeleportOrBringPlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(140567396u, new RpcReceiveHandler(__rpc_handler_140567396), "TeleportOrBringPlayerToPosServerRPC");
			((NetworkBehaviour)this).__registerRpc(1743878225u, new RpcReceiveHandler(__rpc_handler_1743878225), "TeleportOrBringPlayerToPosClientRPC");
			((NetworkBehaviour)this).__registerRpc(3030922208u, new RpcReceiveHandler(__rpc_handler_3030922208), "EmergencyMeetingServerRPC");
			((NetworkBehaviour)this).__registerRpc(645728860u, new RpcReceiveHandler(__rpc_handler_645728860), "EmergencyMeetingClientRPC");
			((NetworkBehaviour)this).__registerRpc(1130831606u, new RpcReceiveHandler(__rpc_handler_1130831606), "TeleportPlayerToShipServerRPC");
			((NetworkBehaviour)this).__registerRpc(3851564758u, new RpcReceiveHandler(__rpc_handler_3851564758), "TeleportPlayerToShipClientRPC");
			((NetworkBehaviour)this).__registerRpc(2877773355u, new RpcReceiveHandler(__rpc_handler_2877773355), "EmergencyAllClientRPC");
			((NetworkBehaviour)this).__registerRpc(1013787913u, new RpcReceiveHandler(__rpc_handler_1013787913), "suitStuffServerRPC");
			((NetworkBehaviour)this).__registerRpc(2220492624u, new RpcReceiveHandler(__rpc_handler_2220492624), "suitStuffClientRPC");
			((NetworkBehaviour)this).__registerRpc(1103306623u, new RpcReceiveHandler(__rpc_handler_1103306623), "PlaySoundFromGalServerRPC");
			((NetworkBehaviour)this).__registerRpc(1792589054u, new RpcReceiveHandler(__rpc_handler_1792589054), "PlaySoundServerRPC");
			((NetworkBehaviour)this).__registerRpc(2685797276u, new RpcReceiveHandler(__rpc_handler_2685797276), "PlaySoundClientRPC");
			((NetworkBehaviour)this).__registerRpc(758899621u, new RpcReceiveHandler(__rpc_handler_758899621), "BlockFireExitsServerRPC");
			((NetworkBehaviour)this).__registerRpc(905636504u, new RpcReceiveHandler(__rpc_handler_905636504), "BlockFireExitsClientRPC");
			((NetworkBehaviour)this).__registerRpc(3750907622u, new RpcReceiveHandler(__rpc_handler_3750907622), "FakeFireExitsServerRPC");
			((NetworkBehaviour)this).__registerRpc(2557817672u, new RpcReceiveHandler(__rpc_handler_2557817672), "FakeFireExitsClientRPC");
			((NetworkBehaviour)this).__registerRpc(4043194655u, new RpcReceiveHandler(__rpc_handler_4043194655), "MimicsClientRPC");
			((NetworkBehaviour)this).__registerRpc(642114377u, new RpcReceiveHandler(__rpc_handler_642114377), "InstaJesterServerRPC");
			((NetworkBehaviour)this).__registerRpc(117164783u, new RpcReceiveHandler(__rpc_handler_117164783), "OutsideBrackenServerRPC");
			((NetworkBehaviour)this).__registerRpc(689662337u, new RpcReceiveHandler(__rpc_handler_689662337), "SetNavmeshBrackenClientRPC");
			((NetworkBehaviour)this).__registerRpc(1822380635u, new RpcReceiveHandler(__rpc_handler_1822380635), "MineOverflowServerRPC");
			((NetworkBehaviour)this).__registerRpc(1885465351u, new RpcReceiveHandler(__rpc_handler_1885465351), "TPOverflowServerRPC");
			((NetworkBehaviour)this).__registerRpc(3530438928u, new RpcReceiveHandler(__rpc_handler_3530438928), "DoFollowerFanServerRpc");
			((NetworkBehaviour)this).__registerRpc(1935741099u, new RpcReceiveHandler(__rpc_handler_1935741099), "updateFanClientRpc");
			((NetworkBehaviour)this).__registerRpc(2429683887u, new RpcReceiveHandler(__rpc_handler_2429683887), "TPOverflowOutsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(327805513u, new RpcReceiveHandler(__rpc_handler_327805513), "SpikeOverflowOutsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(111759042u, new RpcReceiveHandler(__rpc_handler_111759042), "TulipTrapeezeServerRPC");
			((NetworkBehaviour)this).__registerRpc(1938579949u, new RpcReceiveHandler(__rpc_handler_1938579949), "TulipTrapeezeMessageServerRPC");
			((NetworkBehaviour)this).__registerRpc(3877144744u, new RpcReceiveHandler(__rpc_handler_3877144744), "TulipTrapeezeClientRPC");
			((NetworkBehaviour)this).__registerRpc(1809311064u, new RpcReceiveHandler(__rpc_handler_1809311064), "CustomTrapServerRPC");
			((NetworkBehaviour)this).__registerRpc(2864267276u, new RpcReceiveHandler(__rpc_handler_2864267276), "CustomScaledTrapServerRPC");
			((NetworkBehaviour)this).__registerRpc(4225785251u, new RpcReceiveHandler(__rpc_handler_4225785251), "spawnTrapOnServerRPC");
			((NetworkBehaviour)this).__registerRpc(337880440u, new RpcReceiveHandler(__rpc_handler_337880440), "CratesOutsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(1991022u, new RpcReceiveHandler(__rpc_handler_1991022), "IFeelSafeServerRPC");
			((NetworkBehaviour)this).__registerRpc(1834581541u, new RpcReceiveHandler(__rpc_handler_1834581541), "SpawnFreebirdJimothyServerRPC");
			((NetworkBehaviour)this).__registerRpc(3113993560u, new RpcReceiveHandler(__rpc_handler_3113993560), "FreebirdJimothyServerRPC");
			((NetworkBehaviour)this).__registerRpc(1474864547u, new RpcReceiveHandler(__rpc_handler_1474864547), "FreebirdJimothyClientRPC");
			((NetworkBehaviour)this).__registerRpc(2824736702u, new RpcReceiveHandler(__rpc_handler_2824736702), "SpawnFreebirdEnemyServerRPC");
			((NetworkBehaviour)this).__registerRpc(2194998330u, new RpcReceiveHandler(__rpc_handler_2194998330), "SpawnEvilFreebirdEnemyServerRPC");
			((NetworkBehaviour)this).__registerRpc(720705928u, new RpcReceiveHandler(__rpc_handler_720705928), "SpawnFreebirdEnemyServerRPC");
			((NetworkBehaviour)this).__registerRpc(2799833363u, new RpcReceiveHandler(__rpc_handler_2799833363), "SpawnFreebirdTrapServerRPC");
			((NetworkBehaviour)this).__registerRpc(2914505128u, new RpcReceiveHandler(__rpc_handler_2914505128), "FreebirdEnemyServerRPC");
			((NetworkBehaviour)this).__registerRpc(649136148u, new RpcReceiveHandler(__rpc_handler_649136148), "FreebirdEnemyClientRPC");
			((NetworkBehaviour)this).__registerRpc(2323478769u, new RpcReceiveHandler(__rpc_handler_2323478769), "EvilFreebirdEnemyServerRPC");
			((NetworkBehaviour)this).__registerRpc(1396131715u, new RpcReceiveHandler(__rpc_handler_1396131715), "EvilFreebirdEnemyClientRPC");
			((NetworkBehaviour)this).__registerRpc(3162837376u, new RpcReceiveHandler(__rpc_handler_3162837376), "FreebirdTrapClientRPC");
			((NetworkBehaviour)this).__registerRpc(1069689894u, new RpcReceiveHandler(__rpc_handler_1069689894), "CratesInsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(4177036667u, new RpcReceiveHandler(__rpc_handler_4177036667), "SeaminesOutsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(509619746u, new RpcReceiveHandler(__rpc_handler_509619746), "BruiserServerRpc");
			((NetworkBehaviour)this).__registerRpc(1113219564u, new RpcReceiveHandler(__rpc_handler_1113219564), "HorseSeatServerRpc");
			((NetworkBehaviour)this).__registerRpc(595075450u, new RpcReceiveHandler(__rpc_handler_595075450), "DespawnObjectTimedServerRpc");
			((NetworkBehaviour)this).__registerRpc(1104638802u, new RpcReceiveHandler(__rpc_handler_1104638802), "DespawnObjectClientRpc");
			((NetworkBehaviour)this).__registerRpc(3192395886u, new RpcReceiveHandler(__rpc_handler_3192395886), "FixBruceClientRpc");
			((NetworkBehaviour)this).__registerRpc(1801495289u, new RpcReceiveHandler(__rpc_handler_1801495289), "BaldServerRpc");
			((NetworkBehaviour)this).__registerRpc(3673164621u, new RpcReceiveHandler(__rpc_handler_3673164621), "FixBaldClientRpc");
			((NetworkBehaviour)this).__registerRpc(1702338290u, new RpcReceiveHandler(__rpc_handler_1702338290), "SetupChangeVoicesServerRpc");
			((NetworkBehaviour)this).__registerRpc(3957042657u, new RpcReceiveHandler(__rpc_handler_3957042657), "SetupChangeVoicesClientRpc");
			((NetworkBehaviour)this).__registerRpc(3742567567u, new RpcReceiveHandler(__rpc_handler_3742567567), "HeheheServerRpc");
			((NetworkBehaviour)this).__registerRpc(716860219u, new RpcReceiveHandler(__rpc_handler_716860219), "HeheheClientRPC");
			((NetworkBehaviour)this).__registerRpc(832386025u, new RpcReceiveHandler(__rpc_handler_832386025), "BerthaOutsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(3704408002u, new RpcReceiveHandler(__rpc_handler_3704408002), "BIGBerthaServerRPC");
			((NetworkBehaviour)this).__registerRpc(3271572806u, new RpcReceiveHandler(__rpc_handler_3271572806), "SpawnSmolCraneServerRPC");
			((NetworkBehaviour)this).__registerRpc(199626830u, new RpcReceiveHandler(__rpc_handler_199626830), "SpawnBeegCraneServerRPC");
			((NetworkBehaviour)this).__registerRpc(93332351u, new RpcReceiveHandler(__rpc_handler_93332351), "BIGSpikeServerRPC");
			((NetworkBehaviour)this).__registerRpc(2668117893u, new RpcReceiveHandler(__rpc_handler_2668117893), "InstantExplodeBerthaServerRPC");
			((NetworkBehaviour)this).__registerRpc(4025333853u, new RpcReceiveHandler(__rpc_handler_4025333853), "LongBerthaServerRPC");
			((NetworkBehaviour)this).__registerRpc(3517025756u, new RpcReceiveHandler(__rpc_handler_3517025756), "spawnMistressServerRPC");
			((NetworkBehaviour)this).__registerRpc(3498325670u, new RpcReceiveHandler(__rpc_handler_3498325670), "scaleOverTimeServerRpc");
			((NetworkBehaviour)this).__registerRpc(2228222119u, new RpcReceiveHandler(__rpc_handler_2228222119), "scaleOverTimeClientRpc");
			((NetworkBehaviour)this).__registerRpc(1941287104u, new RpcReceiveHandler(__rpc_handler_1941287104), "setExplodedServerRpc");
			((NetworkBehaviour)this).__registerRpc(3440863491u, new RpcReceiveHandler(__rpc_handler_3440863491), "setExplodedClientRpc");
			((NetworkBehaviour)this).__registerRpc(2885808221u, new RpcReceiveHandler(__rpc_handler_2885808221), "BerthaOnLeverServerRPC");
			((NetworkBehaviour)this).__registerRpc(1869804163u, new RpcReceiveHandler(__rpc_handler_1869804163), "SkyFanServerRPC");
			((NetworkBehaviour)this).__registerRpc(3769819833u, new RpcReceiveHandler(__rpc_handler_3769819833), "setSuctionServerRPC");
			((NetworkBehaviour)this).__registerRpc(3040266101u, new RpcReceiveHandler(__rpc_handler_3040266101), "setSuctionClientRPC");
			((NetworkBehaviour)this).__registerRpc(3735209893u, new RpcReceiveHandler(__rpc_handler_3735209893), "doPaparazziServerRPC");
			((NetworkBehaviour)this).__registerRpc(2747903296u, new RpcReceiveHandler(__rpc_handler_2747903296), "doMovingCraneServerRPC");
			((NetworkBehaviour)this).__registerRpc(874694681u, new RpcReceiveHandler(__rpc_handler_874694681), "doMadScienceServerRPC");
			((NetworkBehaviour)this).__registerRpc(3441359114u, new RpcReceiveHandler(__rpc_handler_3441359114), "doTulipBomberServerRPC");
			((NetworkBehaviour)this).__registerRpc(1479493512u, new RpcReceiveHandler(__rpc_handler_1479493512), "doImmortalSnailCatServerRPC");
			((NetworkBehaviour)this).__registerRpc(2707631037u, new RpcReceiveHandler(__rpc_handler_2707631037), "ScanSphereDisableClientRPC");
			((NetworkBehaviour)this).__registerRpc(402860998u, new RpcReceiveHandler(__rpc_handler_402860998), "makeLoverServerRPC");
			((NetworkBehaviour)this).__registerRpc(340750533u, new RpcReceiveHandler(__rpc_handler_340750533), "makeLoverClientRPC");
			((NetworkBehaviour)this).__registerRpc(3627880505u, new RpcReceiveHandler(__rpc_handler_3627880505), "makeBadLoverServerRPC");
			((NetworkBehaviour)this).__registerRpc(1295804991u, new RpcReceiveHandler(__rpc_handler_1295804991), "makeBadLoverClientRPC");
			((NetworkBehaviour)this).__registerRpc(3851048414u, new RpcReceiveHandler(__rpc_handler_3851048414), "SilenceTPServerRPC");
			((NetworkBehaviour)this).__registerRpc(838689601u, new RpcReceiveHandler(__rpc_handler_838689601), "SilenceTPClientRPC");
			((NetworkBehaviour)this).__registerRpc(3354025460u, new RpcReceiveHandler(__rpc_handler_3354025460), "MineOverflowOutsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(2611363842u, new RpcReceiveHandler(__rpc_handler_2611363842), "ModifyPitchNotifyServerRPC");
			((NetworkBehaviour)this).__registerRpc(2473680354u, new RpcReceiveHandler(__rpc_handler_2473680354), "ModifyPitchNotifyClientRPC");
			((NetworkBehaviour)this).__registerRpc(1689679895u, new RpcReceiveHandler(__rpc_handler_1689679895), "SwapPlayersServerRPC");
			((NetworkBehaviour)this).__registerRpc(38229397u, new RpcReceiveHandler(__rpc_handler_38229397), "doSwapperServerRPC");
			((NetworkBehaviour)this).__registerRpc(2060446871u, new RpcReceiveHandler(__rpc_handler_2060446871), "SwapPlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(3440472779u, new RpcReceiveHandler(__rpc_handler_3440472779), "swapAllPlayersClientRpc");
			((NetworkBehaviour)this).__registerRpc(1727001893u, new RpcReceiveHandler(__rpc_handler_1727001893), "JackpotServerRPC");
			((NetworkBehaviour)this).__registerRpc(2988314943u, new RpcReceiveHandler(__rpc_handler_2988314943), "SyncItemWeightsClientRPC");
			((NetworkBehaviour)this).__registerRpc(1402293360u, new RpcReceiveHandler(__rpc_handler_1402293360), "MessageToEveryoneServerRPC");
			((NetworkBehaviour)this).__registerRpc(2917276992u, new RpcReceiveHandler(__rpc_handler_2917276992), "MessageToEveryoneClientRPC");
			((NetworkBehaviour)this).__registerRpc(2289938095u, new RpcReceiveHandler(__rpc_handler_2289938095), "MessageToHostServerRPC");
			((NetworkBehaviour)this).__registerRpc(2014332209u, new RpcReceiveHandler(__rpc_handler_2014332209), "MessageToHostClientRPC");
			((NetworkBehaviour)this).__registerRpc(2677031213u, new RpcReceiveHandler(__rpc_handler_2677031213), "becomeAdminServerRPC");
			((NetworkBehaviour)this).__registerRpc(3841283509u, new RpcReceiveHandler(__rpc_handler_3841283509), "becomeAdminClientRPC");
			((NetworkBehaviour)this).__registerRpc(819957672u, new RpcReceiveHandler(__rpc_handler_819957672), "RequestAdminStateServerRpc");
			((NetworkBehaviour)this).__registerRpc(3263671255u, new RpcReceiveHandler(__rpc_handler_3263671255), "MicrowaveBerthaServerRPC");
			((NetworkBehaviour)this).__registerRpc(1473440554u, new RpcReceiveHandler(__rpc_handler_1473440554), "WhereGoServerRPC");
			((NetworkBehaviour)this).__registerRpc(3075898303u, new RpcReceiveHandler(__rpc_handler_3075898303), "WhereGoClientRPC");
			((NetworkBehaviour)this).__registerRpc(77233678u, new RpcReceiveHandler(__rpc_handler_77233678), "doZortServerRpc");
			((NetworkBehaviour)this).__registerRpc(2669257320u, new RpcReceiveHandler(__rpc_handler_2669257320), "doZortStuffServerRpc");
			((NetworkBehaviour)this).__registerRpc(279242426u, new RpcReceiveHandler(__rpc_handler_279242426), "doZortStuffClientRpc");
			((NetworkBehaviour)this).__registerRpc(910001296u, new RpcReceiveHandler(__rpc_handler_910001296), "SameScrapServerRPC");
			((NetworkBehaviour)this).__registerRpc(3232949610u, new RpcReceiveHandler(__rpc_handler_3232949610), "SameScrapAdvancedServerRPC");
			((NetworkBehaviour)this).__registerRpc(2694207006u, new RpcReceiveHandler(__rpc_handler_2694207006), "AllOfOneTPServerRPC");
			((NetworkBehaviour)this).__registerRpc(692558469u, new RpcReceiveHandler(__rpc_handler_692558469), "AllOfOneTPClientRPC");
			((NetworkBehaviour)this).__registerRpc(3837667048u, new RpcReceiveHandler(__rpc_handler_3837667048), "TeleportEggServerRPC");
			((NetworkBehaviour)this).__registerRpc(1101246554u, new RpcReceiveHandler(__rpc_handler_1101246554), "TeleportEggClientRPC");
			((NetworkBehaviour)this).__registerRpc(2760557736u, new RpcReceiveHandler(__rpc_handler_2760557736), "FixGiftBoxesServerRPC");
			((NetworkBehaviour)this).__registerRpc(245144263u, new RpcReceiveHandler(__rpc_handler_245144263), "FixGiftBoxesClientRPC");
			((NetworkBehaviour)this).__registerRpc(3712040132u, new RpcReceiveHandler(__rpc_handler_3712040132), "spicyNuggiesServerRPC");
			((NetworkBehaviour)this).__registerRpc(2141086692u, new RpcReceiveHandler(__rpc_handler_2141086692), "HouseWinServerRPC");
			((NetworkBehaviour)this).__registerRpc(1905863534u, new RpcReceiveHandler(__rpc_handler_1905863534), "spawnStoreItemServerRPC");
			((NetworkBehaviour)this).__registerRpc(3289246364u, new RpcReceiveHandler(__rpc_handler_3289246364), "CustomMonsterServerRPC");
			((NetworkBehaviour)this).__registerRpc(290308596u, new RpcReceiveHandler(__rpc_handler_290308596), "SpawnEnemyAtPosServerRPC");
			((NetworkBehaviour)this).__registerRpc(4191636483u, new RpcReceiveHandler(__rpc_handler_4191636483), "EggFountainServerRPC");
			((NetworkBehaviour)this).__registerRpc(1371214004u, new RpcReceiveHandler(__rpc_handler_1371214004), "explodeItemServerRPC");
			((NetworkBehaviour)this).__registerRpc(2557813352u, new RpcReceiveHandler(__rpc_handler_2557813352), "explodeItemClientRPC");
			((NetworkBehaviour)this).__registerRpc(2508452677u, new RpcReceiveHandler(__rpc_handler_2508452677), "doEvilCutieFlyServerRPC");
			((NetworkBehaviour)this).__registerRpc(3191841926u, new RpcReceiveHandler(__rpc_handler_3191841926), "turretMineExploderServerRPC");
			((NetworkBehaviour)this).__registerRpc(1637841621u, new RpcReceiveHandler(__rpc_handler_1637841621), "doRedPillStuffServerRPC");
			((NetworkBehaviour)this).__registerRpc(101530073u, new RpcReceiveHandler(__rpc_handler_101530073), "doRedPillFixClientRPC");
			((NetworkBehaviour)this).__registerRpc(651724430u, new RpcReceiveHandler(__rpc_handler_651724430), "HealAllServerRPC");
			((NetworkBehaviour)this).__registerRpc(253654510u, new RpcReceiveHandler(__rpc_handler_253654510), "HealAllClientRPC");
			((NetworkBehaviour)this).__registerRpc(1611098485u, new RpcReceiveHandler(__rpc_handler_1611098485), "TurnOffAllLightsServerRPC");
			((NetworkBehaviour)this).__registerRpc(569249862u, new RpcReceiveHandler(__rpc_handler_569249862), "TurnOffAllLightsClientRPC");
			((NetworkBehaviour)this).__registerRpc(3467711789u, new RpcReceiveHandler(__rpc_handler_3467711789), "EnableRebelServerRPC");
			((NetworkBehaviour)this).__registerRpc(3182374205u, new RpcReceiveHandler(__rpc_handler_3182374205), "ReturnPlayerToShipServerRPC");
			((NetworkBehaviour)this).__registerRpc(3343372220u, new RpcReceiveHandler(__rpc_handler_3343372220), "SpawnBeehivesServerRPC");
			((NetworkBehaviour)this).__registerRpc(2609470227u, new RpcReceiveHandler(__rpc_handler_2609470227), "fixBehiveSizeServerRPC");
			((NetworkBehaviour)this).__registerRpc(144497274u, new RpcReceiveHandler(__rpc_handler_144497274), "fixBehiveSizeClientRPC");
			((NetworkBehaviour)this).__registerRpc(141816624u, new RpcReceiveHandler(__rpc_handler_141816624), "ZeroOutBeehiveScrapClientRPC");
			((NetworkBehaviour)this).__registerRpc(1024578127u, new RpcReceiveHandler(__rpc_handler_1024578127), "SpawnWormssServerRPC");
			((NetworkBehaviour)this).__registerRpc(3302520548u, new RpcReceiveHandler(__rpc_handler_3302520548), "SetArmageddonServerRPC");
			((NetworkBehaviour)this).__registerRpc(1129990815u, new RpcReceiveHandler(__rpc_handler_1129990815), "DetonateAtPosClientRPC");
			((NetworkBehaviour)this).__registerRpc(4180608942u, new RpcReceiveHandler(__rpc_handler_4180608942), "JumpscareAllServerRPC");
			((NetworkBehaviour)this).__registerRpc(1666284665u, new RpcReceiveHandler(__rpc_handler_1666284665), "JumpscareAllClientRPC");
			((NetworkBehaviour)this).__registerRpc(4156720066u, new RpcReceiveHandler(__rpc_handler_4156720066), "AlarmCurseServerRPC");
			((NetworkBehaviour)this).__registerRpc(1028527772u, new RpcReceiveHandler(__rpc_handler_1028527772), "AlarmCurseClientRPC");
			((NetworkBehaviour)this).__registerRpc(2750078957u, new RpcReceiveHandler(__rpc_handler_2750078957), "targetPracticeServerRPC");
			((NetworkBehaviour)this).__registerRpc(3516264184u, new RpcReceiveHandler(__rpc_handler_3516264184), "SpawnObjectServerRPC");
			((NetworkBehaviour)this).__registerRpc(211938818u, new RpcReceiveHandler(__rpc_handler_211938818), "SpawnObjectClientRPC");
			((NetworkBehaviour)this).__registerRpc(134965558u, new RpcReceiveHandler(__rpc_handler_134965558), "AdObjectServerRPC");
			((NetworkBehaviour)this).__registerRpc(2959062392u, new RpcReceiveHandler(__rpc_handler_2959062392), "AdObjectClientRPC");
			((NetworkBehaviour)this).__registerRpc(3372655922u, new RpcReceiveHandler(__rpc_handler_3372655922), "AdEnemyServerRPC");
			((NetworkBehaviour)this).__registerRpc(2257413543u, new RpcReceiveHandler(__rpc_handler_2257413543), "AdEnemyClientRPC");
			((NetworkBehaviour)this).__registerRpc(3847537304u, new RpcReceiveHandler(__rpc_handler_3847537304), "forcedFriendshipServerRPC");
			((NetworkBehaviour)this).__registerRpc(1314177342u, new RpcReceiveHandler(__rpc_handler_1314177342), "everyoneFriendsServerRPC");
			((NetworkBehaviour)this).__registerRpc(471580845u, new RpcReceiveHandler(__rpc_handler_471580845), "DoorlockServerRPC");
			((NetworkBehaviour)this).__registerRpc(2317206841u, new RpcReceiveHandler(__rpc_handler_2317206841), "DoorlockClientRPC");
			((NetworkBehaviour)this).__registerRpc(2857123715u, new RpcReceiveHandler(__rpc_handler_2857123715), "ZombieToShipServerRPC");
			((NetworkBehaviour)this).__registerRpc(583255447u, new RpcReceiveHandler(__rpc_handler_583255447), "ZombieSuitClientRPC");
			((NetworkBehaviour)this).__registerRpc(911839294u, new RpcReceiveHandler(__rpc_handler_911839294), "RequestToSyncSuitIDServerRPC");
			((NetworkBehaviour)this).__registerRpc(2960123516u, new RpcReceiveHandler(__rpc_handler_2960123516), "SyncSuitIDClientRPC");
			((NetworkBehaviour)this).__registerRpc(187663145u, new RpcReceiveHandler(__rpc_handler_187663145), "SilenceMinesServerRPC");
			((NetworkBehaviour)this).__registerRpc(3991829361u, new RpcReceiveHandler(__rpc_handler_3991829361), "SilenceMinesClientRPC");
			((NetworkBehaviour)this).__registerRpc(1079351248u, new RpcReceiveHandler(__rpc_handler_1079351248), "TuretHellServerRPC");
			((NetworkBehaviour)this).__registerRpc(762161338u, new RpcReceiveHandler(__rpc_handler_762161338), "TurretHellClientRPC");
			((NetworkBehaviour)this).__registerRpc(3912816191u, new RpcReceiveHandler(__rpc_handler_3912816191), "ShipTurretServerRPC");
			((NetworkBehaviour)this).__registerRpc(1923849739u, new RpcReceiveHandler(__rpc_handler_1923849739), "SpawnPetDogServerRPC");
			((NetworkBehaviour)this).__registerRpc(4203928006u, new RpcReceiveHandler(__rpc_handler_4203928006), "fixDogClientRPC");
			((NetworkBehaviour)this).__registerRpc(3919335840u, new RpcReceiveHandler(__rpc_handler_3919335840), "SpawnDongServerRPC");
			((NetworkBehaviour)this).__registerRpc(4251728437u, new RpcReceiveHandler(__rpc_handler_4251728437), "paperCutServerRPC");
			((NetworkBehaviour)this).__registerRpc(416980391u, new RpcReceiveHandler(__rpc_handler_416980391), "putThingOnDongClientRPC");
			((NetworkBehaviour)this).__registerRpc(2582859660u, new RpcReceiveHandler(__rpc_handler_2582859660), "ShotgunServerRPC");
			((NetworkBehaviour)this).__registerRpc(2298116725u, new RpcReceiveHandler(__rpc_handler_2298116725), "PokeballsServerRPC");
			((NetworkBehaviour)this).__registerRpc(3350416249u, new RpcReceiveHandler(__rpc_handler_3350416249), "MasterballServerRPC");
			((NetworkBehaviour)this).__registerRpc(572928773u, new RpcReceiveHandler(__rpc_handler_572928773), "PathfinderSpawnBlobsServerRPC");
			((NetworkBehaviour)this).__registerRpc(1920027461u, new RpcReceiveHandler(__rpc_handler_1920027461), "PathfinderGiveSpawnerServerRPC");
			((NetworkBehaviour)this).__registerRpc(4050797297u, new RpcReceiveHandler(__rpc_handler_4050797297), "InfiniteStaminaAllServerRPC");
			((NetworkBehaviour)this).__registerRpc(4216319249u, new RpcReceiveHandler(__rpc_handler_4216319249), "InfiniteStaminaAllClientRPC");
			((NetworkBehaviour)this).__registerRpc(882682875u, new RpcReceiveHandler(__rpc_handler_882682875), "PurgeServerRPC");
			((NetworkBehaviour)this).__registerRpc(3689629835u, new RpcReceiveHandler(__rpc_handler_3689629835), "PurgeClientRPC");
			((NetworkBehaviour)this).__registerRpc(1280047076u, new RpcReceiveHandler(__rpc_handler_1280047076), "StartMalfunctioningServerRPC");
			((NetworkBehaviour)this).__registerRpc(2064573050u, new RpcReceiveHandler(__rpc_handler_2064573050), "DoorMalfunctionClientRPC");
			((NetworkBehaviour)this).__registerRpc(300764022u, new RpcReceiveHandler(__rpc_handler_300764022), "AddMoneyServerRPC");
			((NetworkBehaviour)this).__registerRpc(3254398305u, new RpcReceiveHandler(__rpc_handler_3254398305), "TimeScaleServerRPC");
			((NetworkBehaviour)this).__registerRpc(363698876u, new RpcReceiveHandler(__rpc_handler_363698876), "TimeScaleClientRPC");
			((NetworkBehaviour)this).__registerRpc(1077131223u, new RpcReceiveHandler(__rpc_handler_1077131223), "BigDeliveryServerRPC");
			((NetworkBehaviour)this).__registerRpc(1031158208u, new RpcReceiveHandler(__rpc_handler_1031158208), "IncreaseRateServerRPC");
			((NetworkBehaviour)this).__registerRpc(2814116775u, new RpcReceiveHandler(__rpc_handler_2814116775), "SyncRateClientRPC");
			((NetworkBehaviour)this).__registerRpc(3574076843u, new RpcReceiveHandler(__rpc_handler_3574076843), "SpawnMeteorsServerRPC");
			((NetworkBehaviour)this).__registerRpc(2190384021u, new RpcReceiveHandler(__rpc_handler_2190384021), "SpawnMeteorsClientRPC");
			((NetworkBehaviour)this).__registerRpc(3892095964u, new RpcReceiveHandler(__rpc_handler_3892095964), "ForceTakeoffServerRPC");
			((NetworkBehaviour)this).__registerRpc(2908385801u, new RpcReceiveHandler(__rpc_handler_2908385801), "ForceTakeoffClientRPC");
			((NetworkBehaviour)this).__registerRpc(1151577352u, new RpcReceiveHandler(__rpc_handler_1151577352), "FlashbrightServerRPC");
			((NetworkBehaviour)this).__registerRpc(1359570172u, new RpcReceiveHandler(__rpc_handler_1359570172), "FlashbrightClientRPC");
			((NetworkBehaviour)this).__registerRpc(1998713722u, new RpcReceiveHandler(__rpc_handler_1998713722), "ArachnophobiaServerRPC");
			((NetworkBehaviour)this).__registerRpc(3091144464u, new RpcReceiveHandler(__rpc_handler_3091144464), "ArachnophobiaClientRPC");
			((NetworkBehaviour)this).__registerRpc(2481313195u, new RpcReceiveHandler(__rpc_handler_2481313195), "OutsideCoilheadServerRPC");
			((NetworkBehaviour)this).__registerRpc(2759873561u, new RpcReceiveHandler(__rpc_handler_2759873561), "SetCoilheadNavmeshClientRPC");
			((NetworkBehaviour)this).__registerRpc(146844497u, new RpcReceiveHandler(__rpc_handler_146844497), "MovingMinesInitServerRPC");
			((NetworkBehaviour)this).__registerRpc(2783863187u, new RpcReceiveHandler(__rpc_handler_2783863187), "AddMovingMinesClientRPC");
			((NetworkBehaviour)this).__registerRpc(1328528021u, new RpcReceiveHandler(__rpc_handler_1328528021), "MovingBeartrapsServerRPC");
			((NetworkBehaviour)this).__registerRpc(947103770u, new RpcReceiveHandler(__rpc_handler_947103770), "MovingCratesServerRPC");
			((NetworkBehaviour)this).__registerRpc(949600809u, new RpcReceiveHandler(__rpc_handler_949600809), "CrateOpenServerRPC");
			((NetworkBehaviour)this).__registerRpc(3599904130u, new RpcReceiveHandler(__rpc_handler_3599904130), "MovingBeartrapsClientRPC");
			((NetworkBehaviour)this).__registerRpc(4123855474u, new RpcReceiveHandler(__rpc_handler_4123855474), "SuperFlingerServerRPC");
			((NetworkBehaviour)this).__registerRpc(3784076443u, new RpcReceiveHandler(__rpc_handler_3784076443), "CleaningCrewServerRPC");
			((NetworkBehaviour)this).__registerRpc(1182949054u, new RpcReceiveHandler(__rpc_handler_1182949054), "MovingFansServerRPC");
			((NetworkBehaviour)this).__registerRpc(2873323906u, new RpcReceiveHandler(__rpc_handler_2873323906), "AddMovingTrapClientRPC");
			((NetworkBehaviour)this).__registerRpc(373099070u, new RpcReceiveHandler(__rpc_handler_373099070), "MovingSeatrapsServerRPC");
			((NetworkBehaviour)this).__registerRpc(2952040135u, new RpcReceiveHandler(__rpc_handler_2952040135), "AddMovingSeatrapsClientRPC");
			((NetworkBehaviour)this).__registerRpc(523761332u, new RpcReceiveHandler(__rpc_handler_523761332), "MovingTrapsInitServerRPC");
			((NetworkBehaviour)this).__registerRpc(1503931313u, new RpcReceiveHandler(__rpc_handler_1503931313), "HyperShakeServerRPC");
			((NetworkBehaviour)this).__registerRpc(804710399u, new RpcReceiveHandler(__rpc_handler_804710399), "HyperShakeClientRPC");
			((NetworkBehaviour)this).__registerRpc(456732040u, new RpcReceiveHandler(__rpc_handler_456732040), "LeverShakeServerRPC");
			((NetworkBehaviour)this).__registerRpc(2127593152u, new RpcReceiveHandler(__rpc_handler_2127593152), "LeverShakeClientRPC");
			((NetworkBehaviour)this).__registerRpc(2572659893u, new RpcReceiveHandler(__rpc_handler_2572659893), "NeckBreakRandomPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(2108188472u, new RpcReceiveHandler(__rpc_handler_2108188472), "NeckBreakRandomPlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(3224606339u, new RpcReceiveHandler(__rpc_handler_3224606339), "NeckSpinRandomPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(1671800337u, new RpcReceiveHandler(__rpc_handler_1671800337), "NeckSpinRandomPlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(1807548886u, new RpcReceiveHandler(__rpc_handler_1807548886), "EggBootsServerRpc");
			((NetworkBehaviour)this).__registerRpc(2159218070u, new RpcReceiveHandler(__rpc_handler_2159218070), "EggBootsClientRpc");
			((NetworkBehaviour)this).__registerRpc(2123692491u, new RpcReceiveHandler(__rpc_handler_2123692491), "EggBootsAllServerRpc");
			((NetworkBehaviour)this).__registerRpc(4259756343u, new RpcReceiveHandler(__rpc_handler_4259756343), "EggBootsAllClientRpc");
			((NetworkBehaviour)this).__registerRpc(1520326880u, new RpcReceiveHandler(__rpc_handler_1520326880), "spawnExplodeEggServerRpc");
			((NetworkBehaviour)this).__registerRpc(818694272u, new RpcReceiveHandler(__rpc_handler_818694272), "EggBootsTwoServerRpc");
			((NetworkBehaviour)this).__registerRpc(785906226u, new RpcReceiveHandler(__rpc_handler_785906226), "EggBootsTwoClientRpc");
			((NetworkBehaviour)this).__registerRpc(3086860203u, new RpcReceiveHandler(__rpc_handler_3086860203), "spawnExplodeEggTwoServerRpc");
			((NetworkBehaviour)this).__registerRpc(3278899816u, new RpcReceiveHandler(__rpc_handler_3278899816), "RandomStoreItemServerRPC");
			((NetworkBehaviour)this).__registerRpc(4070546234u, new RpcReceiveHandler(__rpc_handler_4070546234), "RandomStoreItemsServerRPC");
			((NetworkBehaviour)this).__registerRpc(269778369u, new RpcReceiveHandler(__rpc_handler_269778369), "ItemSwapServerRPC");
			((NetworkBehaviour)this).__registerRpc(2278535945u, new RpcReceiveHandler(__rpc_handler_2278535945), "ItemSwapClientRPC");
			((NetworkBehaviour)this).__registerRpc(1518082378u, new RpcReceiveHandler(__rpc_handler_1518082378), "GoldenTouchServerRPC");
			((NetworkBehaviour)this).__registerRpc(944189951u, new RpcReceiveHandler(__rpc_handler_944189951), "GoldenTouchClientRPC");
			((NetworkBehaviour)this).__registerRpc(1132514493u, new RpcReceiveHandler(__rpc_handler_1132514493), "LightBurdenServerRPC");
			((NetworkBehaviour)this).__registerRpc(1050435668u, new RpcReceiveHandler(__rpc_handler_1050435668), "LightBurdenClientRPC");
			((NetworkBehaviour)this).__registerRpc(3067940367u, new RpcReceiveHandler(__rpc_handler_3067940367), "ItemDuplicatorServerRPC");
			((NetworkBehaviour)this).__registerRpc(772901213u, new RpcReceiveHandler(__rpc_handler_772901213), "BatteryDrainServerRPC");
			((NetworkBehaviour)this).__registerRpc(1243936304u, new RpcReceiveHandler(__rpc_handler_1243936304), "BatteryDrainClientRPC");
			((NetworkBehaviour)this).__registerRpc(3149579903u, new RpcReceiveHandler(__rpc_handler_3149579903), "HeavyBurdenServerRPC");
			((NetworkBehaviour)this).__registerRpc(1755114273u, new RpcReceiveHandler(__rpc_handler_1755114273), "HeavyBurdenClientRPC");
			((NetworkBehaviour)this).__registerRpc(1795889364u, new RpcReceiveHandler(__rpc_handler_1795889364), "DrunkServerRPC");
			((NetworkBehaviour)this).__registerRpc(1467089812u, new RpcReceiveHandler(__rpc_handler_1467089812), "DrunkClientRPC");
			((NetworkBehaviour)this).__registerRpc(3687388333u, new RpcReceiveHandler(__rpc_handler_3687388333), "RerollServerRPC");
			((NetworkBehaviour)this).__registerRpc(1161080782u, new RpcReceiveHandler(__rpc_handler_1161080782), "SpawnCustomDieServerRPC");
			((NetworkBehaviour)this).__registerRpc(3084187454u, new RpcReceiveHandler(__rpc_handler_3084187454), "RerollAllServerRPC");
			((NetworkBehaviour)this).__registerRpc(1082877690u, new RpcReceiveHandler(__rpc_handler_1082877690), "RerollAllClientRPC");
			((NetworkBehaviour)this).__registerRpc(1258713014u, new RpcReceiveHandler(__rpc_handler_1258713014), "setDiceEffectServerRPC");
			((NetworkBehaviour)this).__registerRpc(2367606725u, new RpcReceiveHandler(__rpc_handler_2367606725), "setDiceEffectClientRPC");
			((NetworkBehaviour)this).__registerRpc(425676860u, new RpcReceiveHandler(__rpc_handler_425676860), "AnythingGrenadeServerRPC");
			((NetworkBehaviour)this).__registerRpc(2712328859u, new RpcReceiveHandler(__rpc_handler_2712328859), "TarotServerRPC");
			((NetworkBehaviour)this).__registerRpc(779827454u, new RpcReceiveHandler(__rpc_handler_779827454), "SpawnGhostsServerRPC");
			((NetworkBehaviour)this).__registerRpc(3712082155u, new RpcReceiveHandler(__rpc_handler_3712082155), "SpawnNutcrackerOutsideServerRPC");
			((NetworkBehaviour)this).__registerRpc(238328387u, new RpcReceiveHandler(__rpc_handler_238328387), "GiveAllDiceServerRPC");
			((NetworkBehaviour)this).__registerRpc(4139743480u, new RpcReceiveHandler(__rpc_handler_4139743480), "doOxydePenaltyServerRpc");
			((NetworkBehaviour)this).__registerRpc(1544793343u, new RpcReceiveHandler(__rpc_handler_1544793343), "doPenaltyServerRPC");
			((NetworkBehaviour)this).__registerRpc(3247726588u, new RpcReceiveHandler(__rpc_handler_3247726588), "SpecialDetonateServerRPC");
			((NetworkBehaviour)this).__registerRpc(1615881557u, new RpcReceiveHandler(__rpc_handler_1615881557), "SpecialDetonatePlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(2123193542u, new RpcReceiveHandler(__rpc_handler_2123193542), "GalDetonateServerRPC");
			((NetworkBehaviour)this).__registerRpc(2102077482u, new RpcReceiveHandler(__rpc_handler_2102077482), "GalDetonatePlayerClientRPC");
			((NetworkBehaviour)this).__registerRpc(3715261571u, new RpcReceiveHandler(__rpc_handler_3715261571), "AllFlyServerRPC");
			((NetworkBehaviour)this).__registerRpc(990091644u, new RpcReceiveHandler(__rpc_handler_990091644), "allFlyClientRPC");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1906074443(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddControllerServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2717902209(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddControllerClientRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2696892243(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0093: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string playerName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref playerName, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string effectName = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				int roll = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref roll);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LogEffectsToOwnerServerRPC(playerName, effectName, roll);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1737623636(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0093: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string playerName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref playerName, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string effectName = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				int roll = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref roll);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LogEffectsToHostClientRPC(playerName, effectName, roll);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1307310058(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0093: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string playerName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref playerName, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string effectName = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				int roll = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref roll);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LogEffectsToSlayerClientRPC(playerName, effectName, roll);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1822397394(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0093: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string playerName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref playerName, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string effectName = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				int roll = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref roll);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LogEffectsToEveryoneClientRPC(playerName, effectName, roll);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1360560965(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RequestEffectConfigServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4142878533(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string effectName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SendConfigClientRPC(playerID, effectName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_79093998(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RequestConfigSyncServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3630596093(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_00a0: 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_00c6: 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_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_0119: 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_014b: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string key = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref key, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string section = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref section, false);
				}
				int type = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref type);
				int ival = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref ival);
				bool bval = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref bval, default(ForPrimitives));
				bool flag3 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag3, default(ForPrimitives));
				string sval = null;
				if (flag3)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref sval, false);
				}
				bool flag4 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag4, default(ForPrimitives));
				string enumVal = null;
				if (flag4)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref enumVal, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SendConfigsClientRPC(playerID, key, section, type, ival, bval, sval, enumVal);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3353804004(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RequestSyncCursedServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1002459835(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				ulong[] cursedIds = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref cursedIds, default(ForPrimitives));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SyncCursedPlayersClientRpc(cursedIds);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_324328356(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).killPlayerServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_515572243(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).killPlayerClientRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_275668481(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FixPlayerServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4005833429(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_004f: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int getInstanceID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref getInstanceID);
				Vector3 targetPosition = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref targetPosition);
				bool isInside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isInside, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MoveTrapServerRpc(getInstanceID, targetPosition, isInside);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3424035373(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string effect = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effect, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).rollEffectRandomPlayerServerRPC(effect);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2557683131(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005b: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string effect = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effect, false);
				}
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ProcessRollEffectClientRPC(effect, playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_26955910(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string who = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref who, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).QueueRandomDiceEffectServerRPC(who);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1559418665(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string who = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref who, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string effectName = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).QueueSpecificDiceEffectServerRPC(who, effectName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_775413581(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_007c: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				EffectType effectType = default(EffectType);
				((FastBufferReader)(ref reader)).ReadValueSafe<EffectType>(ref effectType, default(ForEnums));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string who = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref who, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).QueueSelectTypeServerRPC(effectType, who);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2898041828(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).NemosplosionServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2543568230(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int target2 = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref target2);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).UnkillableServerRpc(target2);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3338645896(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int target2 = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref target2);
				int time = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref time);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).removeKillServerRPC(target2, time);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2450559096(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int target2 = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref target2);
				int time = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref time);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).removeKillClientRPC(target2, time);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1037540588(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_0082: 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_00ba: 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_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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool item = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref item, default(ForPrimitives));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string top = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref top, false);
				}
				bool flag3 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag3, default(ForPrimitives));
				string bottom = null;
				if (flag3)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref bottom, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AdServerRPC(item, name, top, bottom);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1632183355(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_0082: 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_00ba: 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_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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool item = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref item, default(ForPrimitives));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string top = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref top, false);
				}
				bool flag3 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag3, default(ForPrimitives));
				string bottom = null;
				if (flag3)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref bottom, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AdClientRPC(item, name, top, bottom);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4103428810(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TriggerManyAdsServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_433094646(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int num = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref num);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TriggerSelectAdsServerRpc(num);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1369477639(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RandomAdItemServerRpc(name);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1996097052(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_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_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 center = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref center);
				float radius = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref radius, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RequestEmotesInRadiusServerRpc(center, radius);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2209572773(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0040: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong forClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref forClientId);
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PerformRandomEmoteClientRpc(forClientId, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1413525009(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				int health = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref health);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setHealthServerRPC(player, health);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_405187854(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				int health = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref health);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setHealthClientRPC(playerID, health);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4264730339(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005b: 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_0081: 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_00a3: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string enemyName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref enemyName, false);
				}
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				int radius = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref radius);
				bool doSize = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref doSize, default(ForPrimitives));
				Vector3 size = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref size);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnSurroundedServerRPC(enemyName, amount, radius, doSize, size);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2614339007(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005b: 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_0075: 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_0094: 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_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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string enemyName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref enemyName, false);
				}
				int playerInt = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerInt);
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				int radius = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref radius);
				bool doSize = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref doSize, default(ForPrimitives));
				Vector3 size = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref size);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnSurroundedSelectServerRPC(enemyName, playerInt, amount, radius, doSize, size);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2456088190(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005b: 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_0081: 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_00a3: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string trapName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref trapName, false);
				}
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				int radius = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref radius);
				bool doSize = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref doSize, default(ForPrimitives));
				Vector3 size = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref size);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnSurroundedTrapServerRPC(trapName, amount, radius, doSize, size);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1227566611(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_005f: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectId);
				Vector3 size = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref size);
				Quaternion rotation = default(Quaternion);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref rotation);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setSizeClientRPC(objectId, size, rotation);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2881472247(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0049: 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_005e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectSource = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectSource);
				ulong objectTarget = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectTarget);
				bool preserveRatio = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref preserveRatio, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MatchSizeClientRPC(objectSource, objectTarget, preserveRatio);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1580401083(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0052: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong diceNetObj = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref diceNetObj);
				Vector3 size = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref size);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setDiceSizeClientRPC(diceNetObj, size);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2393095572(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).removeShadowsClientRPC(objectId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2164475308(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).spawnFlingerServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1091680114(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netObject = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netObject);
				int super = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref super);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setHorseStuffServerRPC(netObject, super);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1137837317(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_003d: 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_0057: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netObject = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netObject);
				int super = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref super);
				int a = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref a);
				int b = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref b);
				int c = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref c);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setHorseStuffClientRPC(netObject, super, a, b, c);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1535208873(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DelayedReactionServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3851315013(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DelayedReactionClientRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1097447221(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AlarmServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3450213494(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AlarmClientRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3393414643(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ShowAdMenuServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2183580584(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_0029: 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_003e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ShowAdMenuClientRPC(client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1121024086(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FreeCruiserServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_866465074(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004f: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference scrapNetObject = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref scrapNetObject, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DeleteThingServerRPC(scrapNetObject);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1118192716(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).OnStartRoundClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1471895020(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DetonateRandomPlayerServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1224495368(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DoLizardServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3864594486(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool stupidMode = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref stupidMode, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ConfusionPlayerServerRPC(stupidMode);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_361427529(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool stupidMode = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref stupidMode, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ConfusionPlayerClientRPC(stupidMode);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_698961352(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).OopsPlayerServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2884546173(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int suitID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref suitID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).OopsPlayerClientRPC(suitID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3908042166(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DetonatePlayerClientRPC(clientID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3123714467(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ReviveAllPlayersServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_954997453(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ReviveAllPlayersClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_67657836(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).fixRespawnClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3039924435(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).reviveNextServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_221188056(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float percentChance = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref percentChance, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).reviveChanceServerRPC(percentChance);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3347467633(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0052: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int iD = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref iD);
				Vector3 spawnPosition = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref spawnPosition);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RevivePlayerServerRpc(iD, spawnPosition);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3597900664(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0052: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int iD = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref iD);
				Vector3 spawnPosition = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref spawnPosition);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RevivePlayerClientRpc(iD, spawnPosition);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_381327132(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddLifeAllServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1581190059(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddLifeServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_835406534(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_00a6: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string topMessage = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref topMessage, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string message = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SendMessageServerRPC(clientID, topMessage, message);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_29878885(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_00a6: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string topMessage = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref topMessage, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string message = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SendMessageClientRPC(clientID, topMessage, message);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_654414994(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddLifeClientRPC(clientID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4087975116(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0052: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				Vector3 teleportPos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportInsideServerRPC(clientID, teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2709139905(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0052: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				Vector3 teleportPos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportInsideClientRPC(clientID, teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_603695207(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MartyrdomServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_567713551(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MartyrdomClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3858378172(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doMartyrdomServerRPC(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2222788764(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportToShipServerRPC(clientID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2386185210(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportToShipClientRPC(clientID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1449390942(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong enemyID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref enemyID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).despawnEnemyServerRpc(enemyID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2480012683(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				int to = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref to);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportToPlayerServerRPC(clientID, to);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_114950063(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				int to = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref to);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportToPlayerClientRPC(clientID, to);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1165488094(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0049: 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_005e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				int clientID2 = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID2);
				bool bring = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref bring, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportOrBringPlayerServerRPC(clientID, clientID2, bring);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_740943656(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0049: 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_005e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				int clientID2 = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID2);
				bool bring = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref bring, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportOrBringPlayerClientRPC(clientID, clientID2, bring);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_140567396(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0030: 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_004e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportOrBringPlayerToPosServerRPC(pos, userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1743878225(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0030: 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_004e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportOrBringPlayerToPosClientRPC(pos, userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3030922208(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EmergencyMeetingServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_645728860(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EmergencyMeetingClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1130831606(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int plyr = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref plyr);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportPlayerToShipServerRPC(plyr);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3851564758(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int plyr = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref plyr);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportPlayerToShipClientRPC(plyr);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2877773355(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EmergencyAllClientRPC(index);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1013787913(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				int suit = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref suit);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).suitStuffServerRPC(clientID, suit);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2220492624(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				int suit = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref suit);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).suitStuffClientRPC(clientID, suit);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1103306623(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string soundName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref soundName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PlaySoundFromGalServerRPC(soundName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1792589054(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string sound = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref sound, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PlaySoundServerRPC(sound);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2685797276(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string sound = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref sound, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PlaySoundClientRPC(sound);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_758899621(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BlockFireExitsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_905636504(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BlockFireExitsClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3750907622(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FakeFireExitsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2557817672(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FakeFireExitsClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4043194655(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MimicsClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_642114377(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).InstaJesterServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_117164783(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).OutsideBrackenServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_689662337(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SetNavmeshBrackenClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1822380635(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MineOverflowServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1885465351(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TPOverflowServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3530438928(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DoFollowerFanServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1935741099(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netObject = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netObject);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).updateFanClientRpc(netObject);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2429683887(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TPOverflowOutsideServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_327805513(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpikeOverflowOutsideServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_111759042(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TulipTrapeezeServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1938579949(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TulipTrapeezeMessageServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3877144744(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TulipTrapeezeClientRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1809311064(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_008f: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int max = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref max);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string text = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref text, false);
				}
				bool inside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref inside, default(ForPrimitives));
				bool moving = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref moving, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).CustomTrapServerRPC(max, text, inside, moving);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2864267276(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_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_00b1: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int max = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref max);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string text = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref text, false);
				}
				bool inside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref inside, default(ForPrimitives));
				Vector3 scale = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref scale);
				bool moving = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref moving, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).CustomScaledTrapServerRPC(max, text, inside, scale, moving);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4225785251(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005b: 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_0083: 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_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_00ec: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string text = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref text, false);
				}
				int num = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref num);
				bool inside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref inside, default(ForPrimitives));
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				bool usePos = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref usePos, default(ForPrimitives));
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).spawnTrapOnServerRPC(text, num, inside, userID, usePos, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_337880440(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).CratesOutsideServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1991022(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).IFeelSafeServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1834581541(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnFreebirdJimothyServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3113993560(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FreebirdJimothyServerRPC(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1474864547(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FreebirdJimothyClientRPC(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2824736702(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnFreebirdEnemyServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2194998330(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnEvilFreebirdEnemyServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_720705928(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0082: 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_00a4: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool outside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref outside, default(ForPrimitives));
				bool usePos = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref usePos, default(ForPrimitives));
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnFreebirdEnemyServerRPC(name, outside, usePos, pos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2799833363(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_007c: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool random = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref random, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnFreebirdTrapServerRPC(name, random);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2914505128(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FreebirdEnemyServerRPC(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_649136148(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FreebirdEnemyClientRPC(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2323478769(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EvilFreebirdEnemyServerRPC(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1396131715(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EvilFreebirdEnemyClientRPC(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3162837376(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FreebirdTrapClientRPC(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1069689894(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).CratesInsideServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4177036667(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SeaminesOutsideServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_509619746(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BruiserServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1113219564(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HorseSeatServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_595075450(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DespawnObjectTimedServerRpc(objectID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1104638802(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DespawnObjectClientRpc(objectID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3192395886(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FixBruceClientRpc(objectID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1801495289(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BaldServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3673164621(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				ulong baldObject = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref baldObject);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FixBaldClientRpc(player, baldObject);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1702338290(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0058: 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_00b3: 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_009d: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				int[] keys = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref keys, default(ForPrimitives));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				int[] values = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref values, default(ForPrimitives));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SetupChangeVoicesServerRpc(keys, values);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3957042657(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0058: 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_00b3: 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_009d: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				int[] keys = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref keys, default(ForPrimitives));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				int[] values = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref values, default(ForPrimitives));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SetupChangeVoicesClientRpc(keys, values);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3742567567(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HeheheServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_716860219(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int client = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref client);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HeheheClientRPC(client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_832386025(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BerthaOutsideServerRPC(amount);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3704408002(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BIGBerthaServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3271572806(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnSmolCraneServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_199626830(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnBeegCraneServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_93332351(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BIGSpikeServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2668117893(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).InstantExplodeBerthaServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4025333853(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LongBerthaServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3517025756(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).spawnMistressServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3498325670(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_006c: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netObjID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netObjID);
				float time = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref time, default(ForPrimitives));
				float maxYScale = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref maxYScale, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).scaleOverTimeServerRpc(netObjID, time, maxYScale);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2228222119(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_006c: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netObjID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netObjID);
				float time = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref time, default(ForPrimitives));
				float maxYScale = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref maxYScale, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).scaleOverTimeClientRpc(netObjID, time, maxYScale);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1941287104(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0051: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong berthaNetObj = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref berthaNetObj);
				float time = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref time, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setExplodedServerRpc(berthaNetObj, time);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3440863491(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0051: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong berthaNetObj = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref berthaNetObj);
				float time = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref time, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setExplodedClientRpc(berthaNetObj, time);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2885808221(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BerthaOnLeverServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1869804163(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SkyFanServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3769819833(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong suctionServerRPC = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref suctionServerRPC);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setSuctionServerRPC(suctionServerRPC);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3040266101(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong suctionClientRPC = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref suctionClientRPC);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setSuctionClientRPC(suctionClientRPC);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3735209893(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doPaparazziServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2747903296(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doMovingCraneServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_874694681(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int e = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref e);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doMadScienceServerRPC(e);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3441359114(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int e = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref e);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doTulipBomberServerRPC(e);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1479493512(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int e = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref e);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doImmortalSnailCatServerRPC(e);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2707631037(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ScanSphereDisableClientRPC(objectId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_402860998(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int p = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref p);
				int p2 = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref p2);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).makeLoverServerRPC(p, p2);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_340750533(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int p = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref p);
				int p2 = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref p2);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).makeLoverClientRPC(p, p2);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3627880505(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int p = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref p);
				ulong enemyAI = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref enemyAI);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).makeBadLoverServerRPC(p, enemyAI);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1295804991(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int p = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref p);
				ulong enemyAI = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref enemyAI);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).makeBadLoverClientRPC(p, enemyAI);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3851048414(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SilenceTPServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_838689601(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SilenceTPClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3354025460(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MineOverflowOutsideServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2611363842(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ModifyPitchNotifyServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2473680354(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ModifyPitchNotifyClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1689679895(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SwapPlayersServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_38229397(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doSwapperServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2060446871(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int otherUserID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref otherUserID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SwapPlayerClientRPC(userID, otherUserID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3440472779(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0058: 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_00ab: 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_00ea: 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_00d4: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				int[] playerIDs = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref playerIDs, default(ForPrimitives));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				Vector3[] playerPositions = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref playerPositions);
				}
				bool flag3 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag3, default(ForPrimitives));
				bool[] inside = null;
				if (flag3)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref inside, default(ForPrimitives));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).swapAllPlayersClientRpc(playerIDs, playerPositions, inside);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1727001893(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).JackpotServerRPC(userID, amount);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2988314943(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0058: 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_00b3: 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_009d: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] netObjs = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				float[] scrapWeights = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref scrapWeights, default(ForPrimitives));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SyncItemWeightsClientRPC(netObjs, scrapWeights);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1402293360(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string title = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref title, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string message = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MessageToEveryoneServerRPC(title, message);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2917276992(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string title = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref title, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string message = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MessageToEveryoneClientRPC(title, message);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2289938095(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string title = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref title, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string message = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MessageToHostServerRPC(title, message);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2014332209(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string title = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref title, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string message = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MessageToHostClientRPC(title, message);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2677031213(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_006c: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				bool grant = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref grant, default(ForPrimitives));
				bool forced = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref forced, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).becomeAdminServerRPC(userID, grant, forced);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3841283509(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_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_0072: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				bool grant = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref grant, default(ForPrimitives));
				bool forced = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref forced, default(ForPrimitives));
				bool noMessage = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref noMessage, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).becomeAdminClientRPC(userID, grant, forced, noMessage);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_819957672(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong steamId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref steamId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RequestAdminStateServerRpc(steamId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3263671255(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int num = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref num);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MicrowaveBerthaServerRPC(num);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1473440554(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int who = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref who);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).WhereGoServerRPC(who);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3075898303(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int who = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref who);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).WhereGoClientRPC(who);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_77233678(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doZortServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2669257320(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_003d: 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_005d: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong violin = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref violin);
				ulong recorder = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref recorder);
				ulong accordian = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref accordian);
				ulong guitar = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref guitar);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doZortStuffServerRpc(violin, recorder, accordian, guitar);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_279242426(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_003d: 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_005d: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong v = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref v);
				ulong r = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref r);
				ulong a = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref a);
				ulong g = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref g);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doZortStuffClientRpc(v, r, a, g);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_910001296(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0049: 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_0081: 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_00a3: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string scrap = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref scrap, false);
				}
				bool usePos = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref usePos, default(ForPrimitives));
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SameScrapServerRPC(userID, amount, scrap, usePos, pos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3232949610(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0049: 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_0081: 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_009d: 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_00d1: 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_0101: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string scrap = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref scrap, false);
				}
				bool usePos = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref usePos, default(ForPrimitives));
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				int networkPrefabIndex = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref networkPrefabIndex);
				float weightMod = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref weightMod, default(ForPrimitives));
				float scrapValueMod = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref scrapValueMod, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SameScrapAdvancedServerRPC(userID, amount, scrap, usePos, pos, networkPrefabIndex, weightMod, scrapValueMod);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2694207006(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0068: 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_0087: 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_00ba: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] netObjs = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
				}
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				bool usePos = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref usePos, default(ForPrimitives));
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AllOfOneTPServerRPC(netObjs, playerID, usePos, pos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_692558469(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0068: 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_0087: 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_00ba: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] netObjs = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
				}
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				bool usePos = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref usePos, default(ForPrimitives));
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AllOfOneTPClientRPC(netObjs, playerID, usePos, pos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3837667048(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_003e: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference netObjs = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportEggServerRPC(netObjs, playerID, pos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1101246554(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_003e: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference netObjs = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TeleportEggClientRPC(netObjs, playerID, pos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2760557736(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] netObjs = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObjs, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FixGiftBoxesServerRPC(netObjs);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_245144263(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_0076: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference netObjref = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObjref, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string itemName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref itemName, false);
				}
				int val = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref val);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FixGiftBoxesClientRPC(netObjref, itemName, val);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3712040132(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).spicyNuggiesServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2141086692(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HouseWinServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1905863534(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_007b: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string itemName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref itemName, false);
				}
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).spawnStoreItemServerRPC(playerID, itemName, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3289246364(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005b: 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_0081: 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_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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string monsterName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref monsterName, false);
				}
				int amountMin = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amountMin);
				int amountMax = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amountMax);
				bool isInside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isInside, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).CustomMonsterServerRPC(monsterName, amountMin, amountMax, isInside);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_290308596(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0096: 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_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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				bool useSize = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref useSize, default(ForPrimitives));
				Vector3 size = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref size);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnEnemyAtPosServerRPC(name, pos, useSize, size);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4191636483(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int use = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref use);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EggFountainServerRPC(userID, use);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1371214004(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_004b: 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_0082: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectId);
				bool egg = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref egg, default(ForPrimitives));
				int count = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref count);
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).explodeItemServerRPC(objectId, egg, count, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2557813352(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_004b: 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_0082: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objectId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objectId);
				bool egg = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref egg, default(ForPrimitives));
				int count = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref count);
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).explodeItemClientRPC(objectId, egg, count, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2508452677(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doEvilCutieFlyServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3191841926(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool turret = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref turret, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).turretMineExploderServerRPC(turret);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1637841621(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_0065: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool bald = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref bald, default(ForPrimitives));
				bool freebird = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref freebird, default(ForPrimitives));
				bool fish = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref fish, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doRedPillStuffServerRPC(bald, freebird, fish);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_101530073(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_0065: 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_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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool bald = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref bald, default(ForPrimitives));
				bool fish = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref fish, default(ForPrimitives));
				NetworkObjectReference enemyRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref enemyRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doRedPillFixClientRPC(bald, fish, enemyRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_651724430(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HealAllServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_253654510(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HealAllClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1611098485(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TurnOffAllLightsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_569249862(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TurnOffAllLightsClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3467711789(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EnableRebelServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3182374205(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ReturnPlayerToShipServerRPC(clientID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3343372220(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnBeehivesServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2609470227(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).fixBehiveSizeServerRPC(netID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_144497274(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).fixBehiveSizeClientRPC(netID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_141816624(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ZeroOutBeehiveScrapClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1024578127(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnWormssServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3302520548(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool armageddonServerRPC = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref armageddonServerRPC, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SetArmageddonServerRPC(armageddonServerRPC);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1129990815(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DetonateAtPosClientRPC(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4180608942(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int sync = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref sync);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).JumpscareAllServerRPC(sync);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1666284665(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int sync = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref sync);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).JumpscareAllClientRPC(sync);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4156720066(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0030: 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_004f: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				int audioNum = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref audioNum);
				bool isGlitch = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isGlitch, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AlarmCurseServerRPC(position, audioNum, isGlitch);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1028527772(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0030: 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_004f: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				int audioNum = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref audioNum);
				bool isGlitch = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isGlitch, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AlarmCurseClientRPC(position, audioNum, isGlitch);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2750078957(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).targetPracticeServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3516264184(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0049: 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_007b: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int user = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref user);
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnObjectServerRPC(user, amount, name);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_211938818(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0049: 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_007b: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int user = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref user);
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnObjectClientRPC(user, amount, name);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_134965558(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AdObjectServerRPC(name);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2959062392(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_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_00d1: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string top = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref top, false);
				}
				bool flag3 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag3, default(ForPrimitives));
				string bottom = null;
				if (flag3)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref bottom, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AdObjectClientRPC(name, top, bottom);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3372655922(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AdEnemyServerRPC(name);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2257413543(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_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_00d1: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string top = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref top, false);
				}
				bool flag3 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag3, default(ForPrimitives));
				string bottom = null;
				if (flag3)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref bottom, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AdEnemyClientRPC(name, top, bottom);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3847537304(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_004b: 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_006b: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				bool stuck = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref stuck, default(ForPrimitives));
				int min = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref min);
				int max = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref max);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).forcedFriendshipServerRPC(playerID, stuck, min, max);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1314177342(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).everyoneFriendsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_471580845(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DoorlockServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2317206841(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DoorlockClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2857123715(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ZombieToShipServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_583255447(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_003e: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference netObj = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netObj, default(ForNetworkSerializable));
				int suitID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref suitID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ZombieSuitClientRPC(netObj, suitID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_911839294(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004f: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference zombieNet = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref zombieNet, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RequestToSyncSuitIDServerRPC(zombieNet);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2960123516(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_003e: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference zombieNet = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref zombieNet, default(ForNetworkSerializable));
				int zombieSuitID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref zombieSuitID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SyncSuitIDClientRPC(zombieNet, zombieSuitID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_187663145(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SilenceMinesServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3991829361(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SilenceMinesClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1079351248(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TuretHellServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_762161338(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TurretHellClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3912816191(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ShipTurretServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1923849739(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnPetDogServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4203928006(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).fixDogClientRPC(objID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3919335840(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnDongServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4251728437(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).paperCutServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_416980391(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong objID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref objID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).putThingOnDongClientRPC(objID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2582859660(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ShotgunServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2298116725(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PokeballsServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3350416249(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MasterballServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_572928773(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PathfinderSpawnBlobsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1920027461(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PathfinderGiveSpawnerServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4050797297(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).InfiniteStaminaAllServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4216319249(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).InfiniteStaminaAllClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_882682875(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PurgeServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3689629835(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).PurgeClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1280047076(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).StartMalfunctioningServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2064573050(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool closed = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref closed, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DoorMalfunctionClientRPC(closed);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_300764022(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int money = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref money);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddMoneyServerRPC(money);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3254398305(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TimeScaleServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_363698876(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TimeScaleClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1077131223(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BigDeliveryServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1031158208(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).IncreaseRateServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2814116775(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float companyRate = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref companyRate, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SyncRateClientRPC(companyRate);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3574076843(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnMeteorsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2190384021(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnMeteorsClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3892095964(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ForceTakeoffServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2908385801(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ForceTakeoffClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1151577352(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FlashbrightServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1359570172(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).FlashbrightClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1998713722(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ArachnophobiaServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3091144464(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ArachnophobiaClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2481313195(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).OutsideCoilheadServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2759873561(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong coilheadNavmeshClientRPC = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref coilheadNavmeshClientRPC);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SetCoilheadNavmeshClientRPC(coilheadNavmeshClientRPC);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_146844497(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MovingMinesInitServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2783863187(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddMovingMinesClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1328528021(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MovingBeartrapsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_947103770(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MovingCratesServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_949600809(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong netID = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).CrateOpenServerRPC(netID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3599904130(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MovingBeartrapsClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4123855474(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SuperFlingerServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3784076443(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).CleaningCrewServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1182949054(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MovingFansServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2873323906(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_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_0076: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string trapName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref trapName, false);
				}
				bool follower = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref follower, default(ForPrimitives));
				int playerFollowing = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerFollowing);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddMovingTrapClientRPC(trapName, follower, playerFollowing);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_373099070(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MovingSeatrapsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2952040135(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AddMovingSeatrapsClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_523761332(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).MovingTrapsInitServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1503931313(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HyperShakeServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_804710399(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HyperShakeClientRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_456732040(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LeverShakeServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2127593152(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LeverShakeClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2572659893(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).NeckBreakRandomPlayerServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2108188472(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).NeckBreakRandomPlayerClientRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3224606339(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).NeckSpinRandomPlayerServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1671800337(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).NeckSpinRandomPlayerClientRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1807548886(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EggBootsServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2159218070(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EggBootsClientRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2123692491(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EggBootsAllServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4259756343(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EggBootsAllClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1520326880(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).spawnExplodeEggServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_818694272(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EggBootsTwoServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_785906226(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).EggBootsTwoClientRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3086860203(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int player = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref player);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).spawnExplodeEggTwoServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3278899816(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RandomStoreItemServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4070546234(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				int totalItems = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref totalItems);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RandomStoreItemsServerRPC(playerID, totalItems);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_269778369(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ItemSwapServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2278535945(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ItemSwapClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1518082378(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).GoldenTouchServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_944189951(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				int itemSlot = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref itemSlot);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).GoldenTouchClientRPC(playerID, itemSlot);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1132514493(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LightBurdenServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1050435668(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).LightBurdenClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3067940367(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).ItemDuplicatorServerRPC(playerID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_772901213(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BatteryDrainServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1243936304(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).BatteryDrainClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3149579903(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HeavyBurdenServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1755114273(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).HeavyBurdenClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1795889364(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0051: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				bool all = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref all, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DrunkServerRPC(userID, all);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1467089812(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0051: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				bool all = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref all, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).DrunkClientRPC(userID, all);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3687388333(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RerollServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1161080782(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string effectName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnCustomDieServerRPC(userID, effectName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3084187454(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RerollAllServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1082877690(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).RerollAllClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1258713014(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_007c: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference reference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref reference, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string effectName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setDiceEffectServerRPC(reference, effectName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2367606725(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_007c: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference reference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref reference, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string effectName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref effectName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).setDiceEffectClientRPC(reference, effectName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_425676860(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AnythingGrenadeServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2712328859(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).TarotServerRPC(userID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_779827454(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnGhostsServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3712082155(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpawnNutcrackerOutsideServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_238328387(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int dice = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref dice);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).GiveAllDiceServerRPC(userID, dice);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4139743480(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doOxydePenaltyServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1544793343(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int amount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref amount);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).doPenaltyServerRPC(amount);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3247726588(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpecialDetonateServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1615881557(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int clientID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).SpecialDetonatePlayerClientRPC(clientID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2123193542(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).GalDetonateServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2102077482(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).GalDetonatePlayerClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3715261571(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).AllFlyServerRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_990091644(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Networker)(object)target).allFlyClientRPC();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "Networker";
		}
	}
	public class Spinner : MonoBehaviour
	{
		public bool IsBeingUsed = false;

		private float SpinVelocity = 0f;

		private float SpinAcceleration = 100f;

		private float NormalSpinVelocity = 90f;

		private float CurrentTimer = 0f;

		private float SpinningTime = 3f;

		public bool NewDice = false;

		private Quaternion InitialRotation;

		private Quaternion FromRotation;

		private void Start()
		{
			//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)
			InitialRotation = ((Component)this).transform.rotation;
		}

		public void StartHyperSpinning(float spinTime)
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Started HyperSpinning");
			}
			IsBeingUsed = true;
			SpinVelocity = NormalSpinVelocity;
			SpinAcceleration = 1000f;
			SpinningTime = spinTime;
		}

		public void StopHyperSpinning()
		{
			//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)
			IsBeingUsed = false;
			SpinVelocity = 0f;
			SpinAcceleration = 0f;
			FromRotation = ((Component)this).transform.rotation;
		}

		private void Update()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			if (IsBeingUsed)
			{
				CurrentTimer += Time.deltaTime;
				if (CurrentTimer >= SpinningTime)
				{
					StopHyperSpinning();
				}
			}
			if (!IsBeingUsed)
			{
				if (NewDice)
				{
					((Component)this).transform.Rotate(Vector3.forward, NormalSpinVelocity * Time.deltaTime);
				}
				else
				{
					((Component)this).transform.Rotate(Vector3.up, NormalSpinVelocity * Time.deltaTime);
				}
			}
			else
			{
				SpinVelocity += SpinAcceleration * Time.deltaTime;
				((Component)this).transform.Rotate(Vector3.up, SpinVelocity * Time.deltaTime);
				((Component)this).transform.Rotate(Vector3.forward, SpinVelocity * Time.deltaTime);
				((Component)this).transform.Rotate(Vector3.right, SpinVelocity * Time.deltaTime);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "MysteryDice";

		public const string PLUGIN_NAME = "MysteryDice";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace MysteryDice.Visual
{
	public class HaloSpin : MonoBehaviour
	{
		private void Update()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.rotation = Quaternion.Euler(Mathf.Sin(Time.time) * 15f, Time.time * 30f % 360f, 0f);
		}
	}
	public class Jumpscare : MonoBehaviour
	{
		private bool IsScaring = false;

		private GameObject ScaryFace = null;

		private GameObject Emergency = null;

		public List<KeyValuePair<GameObject, ScareFace>> scarePairs = new List<KeyValuePair<GameObject, ScareFace>>();

		private Vector2 BaseSize = new Vector2(4f, 4f);

		public int getIntNonScary()
		{
			int result = -1;
			List<int> list = new List<int>();
			list = ((!MysteryDice.insideJoke.Value) ? (from p in scarePairs.Select((KeyValuePair<GameObject, ScareFace> pair, int i) => (pair: pair, i: i))
				where (Object)(object)p.pair.Key != (Object)(object)ScaryFace && (Object)(object)p.pair.Key != (Object)(object)Emergency
				select p.i).ToList() : (from p in scarePairs.Select((KeyValuePair<GameObject, ScareFace> pair, int i) => (pair: pair, i: i))
				where (Object)(object)p.pair.Key != (Object)(object)ScaryFace && (Object)(object)p.pair.Key != (Object)(object)Emergency && ((Object)p.pair.Key).name != "Bald" && ((Object)p.pair.Key).name != "rigo" && ((Object)p.pair.Key).name != "funo" && ((Object)p.pair.Key).name != "tree"
				select p.i).ToList());
			if (list.Count > 0)
			{
				result = list[Random.Range(0, list.Count)];
			}
			else
			{
				MysteryDice.CustomLogger.LogWarning((object)"getIntNonScary: No valid non-scary entries found.");
			}
			return result;
		}

		public int getIntScary()
		{
			int num = scarePairs.FindIndex((KeyValuePair<GameObject, ScareFace> p) => (Object)(object)p.Key == (Object)(object)ScaryFace);
			if (num == -1)
			{
				MysteryDice.CustomLogger.LogWarning((object)"getIntScary: ScaryFace not found in scarePairs.");
			}
			return num;
		}

		public int GetIntEmergency()
		{
			int num = scarePairs.FindIndex((KeyValuePair<GameObject, ScareFace> p) => (Object)(object)p.Key == (Object)(object)Emergency);
			if (num == -1)
			{
				MysteryDice.CustomLogger.LogWarning((object)"GetIntEmergency: Emergency face not found in scarePairs.");
			}
			return num;
		}

		private void Start()
		{
			//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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			if (MysteryDice.pussyMode.Value)
			{
				BaseSize = new Vector2(1f, 1f);
			}
			scarePairs = new List<KeyValuePair<GameObject, ScareFace>>();
			foreach (Transform item in ((Component)this).transform)
			{
				Transform val = item;
				GameObject gameObject = ((Component)val).gameObject;
				ScareFace component = gameObject.GetComponent<ScareFace>();
				gameObject.SetActive(false);
				if (!((Object)(object)component == (Object)null))
				{
					scarePairs.Add(new KeyValuePair<GameObject, ScareFace>(gameObject, component));
					if (((Object)gameObject).name.Equals("Creepy", StringComparison.OrdinalIgnoreCase) || ((Object)gameObject).name.Equals("ScaryFace"))
					{
						ScaryFace = gameObject;
					}
					else if (((Object)gameObject).name.Equals("Emergency", StringComparison.OrdinalIgnoreCase))
					{
						Emergency = gameObject;
					}
				}
			}
			if ((Object)(object)ScaryFace == (Object)null)
			{
				MysteryDice.CustomLogger.LogWarning((object)"ScaryFace not found!");
			}
			if ((Object)(object)Emergency == (Object)null)
			{
				MysteryDice.CustomLogger.LogWarning((object)"Emergency face not found!");
			}
		}

		public void Scare(int sync)
		{
			((MonoBehaviour)this).StartCoroutine(ScareTime(sync));
		}

		private void Update()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (IsScaring)
			{
				ScaryFace.transform.localScale = new Vector3(BaseSize.x + Random.Range(0f, 0.2f), BaseSize.y + Random.Range(0f, 0.2f), 1f);
			}
		}

		private IEnumerator ScareTime(int sync, bool meeting = false)
		{
			KeyValuePair<GameObject, ScareFace> selected = scarePairs.ElementAt(sync);
			GameObject faceToShow = selected.Key;
			string clipKey = selected.Value.getRandomSoundKey();
			if (!MysteryDice.pussyMode.Value)
			{
				faceToShow = ScaryFace;
				clipKey = "glitch";
			}
			if (meeting)
			{
				faceToShow = Emergency;
				clipKey = "Meeting_Sound";
			}
			if (MysteryDice.sounds.TryGetValue(clipKey, out var clip) && (Object)(object)clip != (Object)null)
			{
				GameObject tempAudio = new GameObject("TempAudio");
				tempAudio.transform.position = ((Component)GameNetworkManager.Instance.localPlayerController).transform.position;
				AudioSource source = tempAudio.AddComponent<AudioSource>();
				source.clip = clip;
				source.spatialBlend = 0f;
				source.minDistance = 5f;
				source.maxDistance = 15f;
				source.rolloffMode = (AudioRolloffMode)1;
				source.dopplerLevel = 0f;
				source.volume = MysteryDice.SoundVolume.Value;
				source.playOnAwake = false;
				source.pitch = Random.Range(0.8f, 1.2f);
				source.Play();
				Object.Destroy((Object)(object)tempAudio, clip.length);
			}
			else
			{
				MysteryDice.CustomLogger.LogWarning((object)("Failed to find audio clip for key: '" + clipKey + "'"));
			}
			IsScaring = true;
			faceToShow.SetActive(true);
			yield return (object)new WaitForSeconds(1.3f);
			IsScaring = false;
			faceToShow.SetActive(false);
		}
	}
	public class ScareFace : MonoBehaviour
	{
		public List<string> soundKeys = new List<string>();

		public string getRandomSoundKey()
		{
			if (soundKeys == null || soundKeys.Count == 0)
			{
				return "purr";
			}
			return soundKeys[Random.Range(0, soundKeys.Count)];
		}
	}
	[RequireComponent(typeof(Image))]
	public class UISpritesAnimation : MonoBehaviour
	{
		public float duration;

		[SerializeField]
		private Sprite[] sprites;

		private Image image;

		private int index = 0;

		private float timer = 0f;

		private void Start()
		{
			image = ((Component)this).GetComponent<Image>();
		}

		private void Update()
		{
			if ((timer += Time.deltaTime) >= duration / (float)sprites.Length)
			{
				timer = 0f;
				image.sprite = sprites[index];
				index = (index + 1) % sprites.Length;
			}
		}
	}
}
namespace MysteryDice.Patches
{
	[HarmonyPatch(typeof(HUDManager))]
	internal class ChatPatch
	{
		private const string BaseCommand = "~edice ";

		[HarmonyPatch("SubmitChat_performed")]
		[HarmonyPrefix]
		private static void ChatTesting(HUDManager __instance)
		{
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			string text = __instance.chatTextField.text.ToLower();
			if (text == "/visor" || text == "\\visor")
			{
				ToggleVisor();
				Misc.SafeTipMessage("Visor Toggled", "Run the command again to toggle it back");
			}
			if (text == "/fixhud" || text == "\\fixhud")
			{
				((Behaviour)HUDManager.Instance).enabled = true;
				HUDManager.Instance.ToggleHUD(true);
			}
			if ((SelectEffect.isSpecial() || ((NetworkBehaviour)StartOfRound.Instance).IsHost) && text == "/listcurse")
			{
				string body = string.Join(", ", Networker.Instance.cursedPeople.Select((ulong id) => Misc.getPlayerBySteamID(id)?.playerUsername ?? "Unknown"));
				Misc.SafeTipMessage("Current Cursed Players:", body);
			}
			if (!MysteryDice.allowChatCommands.Value)
			{
				return;
			}
			if (text == "~edice enemies")
			{
				MysteryDice.CustomLogger.LogMessage((object)"Registered enemies:");
				foreach (SpawnableEnemyWithRarity enemy in RoundManager.Instance.currentLevel.Enemies)
				{
					MysteryDice.CustomLogger.LogMessage((object)enemy.enemyType.enemyName);
				}
			}
			if (text.Contains("~edice dice"))
			{
				string[] array = text.Split(' ');
				if (array.Length < 3)
				{
					return;
				}
				if (int.TryParse(array[2], out var result))
				{
					GameObject spawnPrefab = MysteryDice.DieEmergency.spawnPrefab;
					switch (result)
					{
					case 1:
						spawnPrefab = MysteryDice.DieEmergency.spawnPrefab;
						break;
					case 2:
						spawnPrefab = MysteryDice.DieGambler.spawnPrefab;
						break;
					case 3:
						spawnPrefab = MysteryDice.DieChronos.spawnPrefab;
						break;
					case 4:
						spawnPrefab = MysteryDice.DieSacrificer.spawnPrefab;
						break;
					case 5:
						spawnPrefab = MysteryDice.DieSaint.spawnPrefab;
						break;
					case 6:
						spawnPrefab = MysteryDice.DieRusty.spawnPrefab;
						break;
					}
					GameObject val = Object.Instantiate<GameObject>(spawnPrefab, ((Component)GameNetworkManager.Instance.localPlayerController).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
					val.GetComponent<GrabbableObject>().fallTime = 0f;
					val.GetComponent<NetworkObject>().Spawn(false);
					CullFactorySoftCompat.RefreshGrabbableObjectPosition(val.GetComponent<GrabbableObject>());
					val.GetComponent<GrabbableObject>().EnablePhysics(true);
				}
			}
			if (text.Contains("~edice menu"))
			{
				MysteryDice.DebugMenu(bypassButton: true);
			}
			foreach (IEffect allEffect in DieBehaviour.AllEffects)
			{
				if (text.Contains("~edice effect " + allEffect.Name.ToLower()) || text.Contains("~edice e " + allEffect.Name.ToLower()))
				{
					allEffect.Use();
				}
			}
		}

		public static void ToggleVisor()
		{
			GameObject val = GameObject.Find("Systems/Rendering/PlayerHUDHelmetModel/ScavengerHelmet");
			MeshRenderer component = val.GetComponent<MeshRenderer>();
			((Renderer)component).enabled = !((Renderer)component).enabled;
		}
	}
	[HarmonyPatch(typeof(EntranceTeleport))]
	internal class EntranceTeleportPatch
	{
	}
	[HarmonyPatch(typeof(EntranceTeleport))]
	internal class FireExitPatch
	{
		public static bool AreFireExitsBlocked;

		[HarmonyPatch("TeleportPlayer")]
		[HarmonyPrefix]
		public static bool BlockEntrance(EntranceTeleport __instance)
		{
			if (AreFireExitsBlocked && __instance.entranceId != 0)
			{
				Misc.SafeTipMessage("Locked", "Something locked the fire exit?");
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(FlashlightItem))]
	internal class FlashlightItemPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void BrightFlashlightUpdate(FlashlightItem __instance)
		{
			if (!((Object)((Component)__instance).gameObject).name.Contains("Laser") && BrightFlashlight.IsEnabled)
			{
				Light flashlightBulb = __instance.flashlightBulb;
				flashlightBulb.intensity *= 1.2f;
				__instance.flashlightBulb.spotAngle = 160f;
			}
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	public class GetEnemies
	{
		public static SpawnableEnemyWithRarity Masked;

		public static SpawnableEnemyWithRarity RedwoodTitan;

		public static SpawnableEnemyWithRarity Jimothy;

		public static SpawnableEnemyWithRarity Janitor;

		public static SpawnableEnemyWithRarity HoardingBug;

		public static SpawnableEnemyWithRarity Scary;

		public static SpawnableEnemyWithRarity Ghost;

		public static SpawnableEnemyWithRarity Boomba;

		public static SpawnableEnemyWithRarity Tulip;

		public static SpawnableEnemyWithRarity Centipede;

		public static SpawnableEnemyWithRarity Dog;

		public static SpawnableEnemyWithRarity Jester;

		public static SpawnableEnemyWithRarity Bracken;

		public static SpawnableEnemyWithRarity Stomper;

		public static SpawnableEnemyWithRarity Coilhead;

		public static SpawnableEnemyWithRarity Beehive;

		public static SpawnableEnemyWithRarity Sandworm;

		public static SpawnableEnemyWithRarity Spider;

		public static SpawnableEnemyWithRarity Giant;

		public static SpawnableEnemyWithRarity Maneater;

		public static SpawnableEnemyWithRarity Nutcracker;

		public static SpawnableEnemyWithRarity Shrimp;

		public static SpawnableEnemyWithRarity CrystalRay;

		public static SpawnableEnemyWithRarity Lasso;

		public static SpawnableEnemyWithRarity Barber;

		public static SpawnableEnemyWithRarity BellCrab;

		public static SpawnableEnemyWithRarity Urchin;

		public static SpawnableEnemyWithRarity Horse;

		public static SpawnableEnemyWithRarity Nemo;

		public static SpawnableEnemyWithRarity Bruce;

		public static SpawnableEnemyWithRarity MantisShrimp;

		public static SpawnableEnemyWithRarity Tornado;

		public static SpawnableMapObject SpawnableLandmine;

		public static SpawnableMapObject SpawnableTurret;

		public static SpawnableMapObject SpawnableTP;

		public static SpawnableMapObject SpawnableSpikeTrap;

		public static SpawnableMapObject Microwave;

		public static SpawnableMapObject Fan;

		public static SpawnableMapObject FlashTurret;

		public static SpawnableMapObject Seamine;

		public static SpawnableMapObject Bertha;

		public static List<SpawnableOutsideObjectWithRarity> trees = new List<SpawnableOutsideObjectWithRarity>();

		private static readonly string teleporterTrapId = "TeleporterTrap";

		public static List<EnemyType> allEnemies = new List<EnemyType>();

		public static List<SpawnableOutsideObject> allObjects = new List<SpawnableOutsideObject>();

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void GetEnemy(Terminal __instance)
		{
			if (allEnemies.Count == 0)
			{
				allEnemies = Resources.FindObjectsOfTypeAll<EnemyType>().ToList();
			}
			if (allObjects.Count == 0)
			{
				allObjects = Resources.FindObjectsOfTypeAll<SpawnableOutsideObject>().ToList();
			}
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogInfo((object)("AllEnemies: " + allEnemies.Count));
				foreach (EnemyType allEnemy in allEnemies)
				{
					MysteryDice.CustomLogger.LogInfo((object)("Enemy Found: " + allEnemy.enemyName));
				}
			}
			SelectableLevel[] moonsCatalogueList = __instance.moonsCatalogueList;
			foreach (SelectableLevel val in moonsCatalogueList)
			{
				foreach (SpawnableEnemyWithRarity enemy in val.Enemies)
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogInfo((object)("Enemy Found Inside: " + enemy.enemyType.enemyName));
					}
					if (enemy.enemyType.enemyName == "Masked")
					{
						Masked = enemy;
					}
					if (enemy.enemyType.enemyName == "Hoarding bug")
					{
						HoardingBug = enemy;
					}
					if (enemy.enemyType.enemyName == "Centipede")
					{
						Centipede = enemy;
					}
					if (enemy.enemyType.enemyName == "Jester")
					{
						Jester = enemy;
					}
					if (enemy.enemyType.enemyName == "Flowerman")
					{
						Bracken = enemy;
					}
					if (enemy.enemyType.enemyName == "Crawler")
					{
						Stomper = enemy;
					}
					if (enemy.enemyType.enemyName == "Spring")
					{
						Coilhead = enemy;
					}
					if (enemy.enemyType.enemyName == "Bunker Spider")
					{
						Spider = enemy;
					}
					if (enemy.enemyType.enemyName == "Maneater")
					{
						Maneater = enemy;
					}
					if (enemy.enemyType.enemyName == "Shrimp")
					{
						Shrimp = enemy;
					}
					if (enemy.enemyType.enemyName == "Crystal Ray")
					{
						CrystalRay = enemy;
					}
					if (enemy.enemyType.enemyName == "Lasso")
					{
						Lasso = enemy;
					}
					if (enemy.enemyType.enemyName == "Clay Surgeon")
					{
						Barber = enemy;
					}
					if (enemy.enemyType.enemyName == "Mantis Shrimp")
					{
						MantisShrimp = enemy;
					}
					if (enemy.enemyType.enemyName == "BellCrab")
					{
						BellCrab = enemy;
					}
					if (enemy.enemyType.enemyName == "Nutcracker")
					{
						Nutcracker = enemy;
					}
					if (enemy.enemyType.enemyName == "Girl")
					{
						Ghost = enemy;
					}
					if (enemy.enemyType.enemyName == "Boomba")
					{
						Boomba = enemy;
					}
					if (enemy.enemyType.enemyName == "Scary")
					{
						Scary = enemy;
					}
					if (enemy.enemyType.enemyName == "Transporter")
					{
						Jimothy = enemy;
					}
					if (enemy.enemyType.enemyName == "Janitor")
					{
						Janitor = enemy;
					}
				}
				foreach (SpawnableEnemyWithRarity daytimeEnemy in val.DaytimeEnemies)
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogInfo((object)("Enemy Found Daytime: " + daytimeEnemy.enemyType.enemyName));
					}
					if (daytimeEnemy.enemyType.enemyName == "Red Locust Bees")
					{
						Beehive = daytimeEnemy;
					}
					if (daytimeEnemy.enemyType.enemyName == "Urchin")
					{
						Urchin = daytimeEnemy;
					}
					if (daytimeEnemy.enemyType.enemyName == "Horse")
					{
						Horse = daytimeEnemy;
					}
					if (daytimeEnemy.enemyType.enemyName == "Nemo")
					{
						Nemo = daytimeEnemy;
					}
					if (daytimeEnemy.enemyType.enemyName == "Tulip Snake")
					{
						Tulip = daytimeEnemy;
					}
				}
				foreach (SpawnableEnemyWithRarity outsideEnemy in val.OutsideEnemies)
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogInfo((object)("Enemy Found Outside: " + outsideEnemy.enemyType.enemyName));
					}
					if (outsideEnemy.enemyType.enemyName == "Earth Leviathan")
					{
						Sandworm = outsideEnemy;
					}
					if (outsideEnemy.enemyType.enemyName == "ForestGiant")
					{
						Giant = outsideEnemy;
					}
					if (outsideEnemy.enemyType.enemyName == "MouthDog")
					{
						Dog = outsideEnemy;
					}
					if (outsideEnemy.enemyType.enemyName == "Bruce")
					{
						Bruce = outsideEnemy;
					}
					if (outsideEnemy.enemyType.enemyName == "Tornado")
					{
						Tornado = outsideEnemy;
					}
					if (outsideEnemy.enemyType.enemyName == "Redwood Titan")
					{
						RedwoodTitan = outsideEnemy;
					}
				}
				SpawnableMapObject[] spawnableMapObjects = val.spawnableMapObjects;
				foreach (SpawnableMapObject val2 in spawnableMapObjects)
				{
					if (val2 == null || (Object)(object)val2.prefabToSpawn == (Object)null)
					{
						continue;
					}
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogInfo((object)("Spawnable Map Object Found: " + ((Object)val2.prefabToSpawn).name));
					}
					if (((Object)val2.prefabToSpawn).name == "Landmine" && SpawnableLandmine == null)
					{
						SpawnableLandmine = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "TurretContainer" && SpawnableTurret == null)
					{
						SpawnableTurret = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "SpikeRoofTrapHazard" && SpawnableSpikeTrap == null)
					{
						SpawnableSpikeTrap = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "TeleporterTrap" && SpawnableTP == null)
					{
						SpawnableTP = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "Seamine" && Seamine == null)
					{
						Seamine = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "Bertha" && Bertha == null)
					{
						Bertha = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "FunctionalMicrowave" && Microwave == null)
					{
						Microwave = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "FanTrapAnimated" && Fan == null)
					{
						Fan = val2;
					}
					if (((Object)val2.prefabToSpawn).name == "FlashTurretUpdated" && FlashTurret == null)
					{
						FlashTurret = val2;
					}
					try
					{
						if (MysteryDice.DebugLogging.Value)
						{
							MysteryDice.CustomLogger.LogInfo((object)("Spawnable Map Object Found: " + ((Object)val2.prefabToSpawn).name));
						}
						if (((Object)val2.prefabToSpawn).name == "Landmine" && SpawnableLandmine == null)
						{
							SpawnableLandmine = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "TurretContainer" && SpawnableTurret == null)
						{
							SpawnableTurret = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "SpikeRoofTrapHazard" && SpawnableSpikeTrap == null)
						{
							SpawnableSpikeTrap = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "TeleporterTrap" && SpawnableTP == null)
						{
							SpawnableTP = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "Seamine" && Seamine == null)
						{
							Seamine = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "Bertha" && Bertha == null)
						{
							Bertha = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "FunctionalMicrowave" && Microwave == null)
						{
							Microwave = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "FanTrapAnimated" && Fan == null)
						{
							Fan = val2;
						}
						if (((Object)val2.prefabToSpawn).name == "FlashTurretUpdated" && FlashTurret == null)
						{
							FlashTurret = val2;
						}
					}
					catch (Exception ex)
					{
						MysteryDice.CustomLogger.LogWarning((object)("Wat " + ex.Message));
					}
				}
				SpawnableOutsideObjectWithRarity[] spawnableOutsideObjects = val.spawnableOutsideObjects;
				foreach (SpawnableOutsideObjectWithRarity val3 in spawnableOutsideObjects)
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogInfo((object)("Spawnable Outside Object Found: " + ((Object)val3.spawnableObject.prefabToSpawn).name));
					}
					if (val3 != null && ((Object)val3.spawnableObject.prefabToSpawn).name.ToUpper().Contains("TREE") && !trees.Contains(val3))
					{
						trees.Add(val3);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(GrabbableObject))]
	internal class GrabbableObjectPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("EquipItem")]
		public static void EquipItem(GrabbableObject __instance)
		{
			if (!MysteryDice.DebugLogging.Value)
			{
				return;
			}
			string text = "Picked up Item: ";
			if (!Misc.isPlayerLocal(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, __instance.playerHeldBy)))
			{
				return;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"Item is null.");
				return;
			}
			text = text + ((Object)__instance).name + " ";
			if ((Object)(object)__instance.itemProperties.spawnPrefab != (Object)null)
			{
				text = text + "with prefab name " + ((Object)__instance.itemProperties.spawnPrefab).name + " ";
			}
			if ((Object)(object)__instance.itemProperties != (Object)null)
			{
				text = text + "and item properties name: " + ((Object)__instance.itemProperties).name + " ";
			}
			MysteryDice.CustomLogger.LogInfo((object)text);
		}
	}
	[HarmonyPatch(typeof(HoarderBugAI))]
	public class HoarderBugAIPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void start(HoarderBugAI __instance)
		{
			HoarderBugCache hoarderBugCache = ((Component)__instance).gameObject.AddComponent<HoarderBugCache>();
			hoarderBugCache.instance = __instance;
		}
	}
	public class HoarderBugCache : MonoBehaviour
	{
		public float timeSince = 0f;

		public HoarderBugAI instance;

		public GrabbableObject heldItem;

		public bool isDice = false;

		[CanBeNull]
		private DieBehaviour die = null;

		private void Awake()
		{
			try
			{
				instance = ((Component)this).GetComponent<HoarderBugAI>();
			}
			catch (Exception)
			{
			}
		}

		public void Update()
		{
			try
			{
				if (instance.heldItem == null)
				{
					return;
				}
				if ((Object)(object)instance.heldItem.itemGrabbableObject != (Object)(object)heldItem)
				{
					die = null;
					isDice = false;
					heldItem = instance.heldItem.itemGrabbableObject;
					if (((Component)heldItem).TryGetComponent<DieBehaviour>(ref die))
					{
						isDice = true;
					}
				}
				if (!((NetworkBehaviour)StartOfRound.Instance).IsServer || !((NetworkBehaviour)instance).IsOwner || !MysteryDice.yippeeUse.Value)
				{
					return;
				}
				if (isDice)
				{
					timeSince += Time.deltaTime;
					if (timeSince >= 5f)
					{
						timeSince = 0f;
						int num = Random.Range(0, 100);
						if (MysteryDice.aprilFoolsConfig.Value)
						{
							num -= 10;
						}
						if (num <= 20)
						{
							die?.SyncDropServerRPC(6409046, Random.Range(0, 10));
							instance.heldItem = null;
							isDice = false;
						}
					}
				}
				else
				{
					timeSince = 0f;
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal class HudManagerPatch
	{
		[HarmonyPatch("displayAd")]
		[HarmonyPrefix]
		public static void DeadAd(HUDManager __instance)
		{
			if (MysteryDice.deadAds.Value && StartOfRound.Instance.localPlayerController.isPlayerDead)
			{
				__instance.advertAnimator.SetTrigger("PopUpAd");
			}
		}
	}
	[HarmonyPatch(typeof(KillLocalPlayer), "KillPlayer")]
	public class KillLocalPlayerPatch
	{
		private static bool Prefix(KillLocalPlayer __instance, PlayerControllerB playerWhoTriggered)
		{
			if ((Object)(object)((Component)__instance).gameObject.GetComponentInParent<RedPillChanger>() != (Object)null)
			{
				((MonoBehaviour)__instance).StartCoroutine(DamageOverTime(__instance, playerWhoTriggered));
				return false;
			}
			return true;
		}

		private static IEnumerator DamageOverTime(KillLocalPlayer inst, PlayerControllerB player)
		{
			for (int i = 0; i < 5; i++)
			{
				if ((Object)(object)player == (Object)null || player.isPlayerDead)
				{
					yield break;
				}
				player.DamagePlayer(1, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
				yield return (object)new WaitForSeconds(0.15f);
			}
			yield return (object)new WaitForSeconds(0.1f);
			EnemyAI enemyAI = ((Component)inst).GetComponentInParent<EnemyAI>();
			GameObject[] nodes = RoundManager.Instance.insideAINodes.Concat(RoundManager.Instance.outsideAINodes).ToArray();
			if ((Object)(object)RoundManager.Instance != (Object)null && nodes.Length != 0)
			{
				GameObject randNode = nodes[Random.Range(0, nodes.Length)];
				enemyAI.agent.Warp(randNode.transform.position);
			}
			enemyAI.agent.speed = 3.5f;
		}
	}
	[HarmonyPatch(typeof(MaskedPlayerEnemy))]
	internal class MaskedPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void MaskedOnStart(MaskedPlayerEnemy __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			((MonoBehaviour)__instance).StartCoroutine(WaitInitPrefab(__instance));
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				Networker.Instance.RequestToSyncSuitIDServerRPC(NetworkObjectReference.op_Implicit(((Component)__instance).GetComponent<NetworkObject>()));
			}
		}

		public static IEnumerator WaitInitPrefab(MaskedPlayerEnemy masked)
		{
			if (!((Object)(object)masked == (Object)null))
			{
				float timeout = 2f;
				float t = 0f;
				while ((Object)(object)masked != (Object)null && (Object)(object)masked.mimickingPlayer == (Object)null && t < timeout)
				{
					t += Time.deltaTime;
					yield return null;
				}
				if (!((Object)(object)masked == (Object)null) && !((EnemyAI)masked).isEnemyDead && !((Object)(object)masked.mimickingPlayer == (Object)null))
				{
					Networker.Instance.InstantiateSpecialPrefabForMimic(masked);
				}
			}
		}
	}
	[DisallowMultipleComponent]
	public class OwnerNetworkAnimator : NetworkAnimator
	{
		protected override bool OnIsServerAuthoritative()
		{
			return false;
		}

		protected override void __initializeVariables()
		{
			((NetworkAnimator)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkAnimator)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "OwnerNetworkAnimator";
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	[HarmonyPatch("DamagePlayer", new Type[]
	{
		typeof(int),
		typeof(bool),
		typeof(bool),
		typeof(CauseOfDeath),
		typeof(int),
		typeof(bool),
		typeof(Vector3)
	})]
	internal class Patch_RemoveFallDamage
	{
		private static bool Prefix(PlayerControllerB __instance, int damageNumber, bool hasDamageSFX, bool callRPC, CauseOfDeath causeOfDeath, int deathAnimation, bool fallDamage, Vector3 force)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((fallDamage || __instance.takingFallDamage || (int)causeOfDeath == 2) && Fly.CanFly)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		[HarmonyPatch(typeof(PlayerControllerB))]
		[HarmonyPatch("TeleportPlayer")]
		public class TeleportPlayerPatch
		{
		}

		public static bool HasInfiniteStamina = false;

		public static List<SmartAgentNavigator> smartAgentNavigators = new List<SmartAgentNavigator>();

		[HarmonyPrefix]
		[HarmonyPatch("HasLineOfSightToPosition")]
		public static bool OverrideLineOfSight(ref bool __result)
		{
			if (RebeliousCoilHeads.IsEnabled && Networker.CoilheadIgnoreStares)
			{
				__result = false;
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void InfiniteSprint(ref float ___sprintMeter)
		{
			if (HasInfiniteStamina)
			{
				___sprintMeter = 1f;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void CheckDoubleTap(PlayerControllerB __instance)
		{
			if (!((NetworkBehaviour)__instance).IsOwner)
			{
				return;
			}
			float time = Time.time;
			if (time - Fly.lastTapTime > Fly.tapCooldown)
			{
				Fly.tapCount = 0;
			}
			if (MysteryDice.Keybinds.FlyButton.WasPressedThisFrame())
			{
				Fly.tapCount++;
				if (Fly.tapCount >= 2)
				{
					Fly.isFlying = !Fly.isFlying;
					Fly.tapCount = 0;
				}
				Fly.lastTapTime = time;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void CheckIfGrounded(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.IsPlayerNearGround() && Fly.isFlying)
			{
				Fly.isFlying = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void FlyMode(PlayerControllerB __instance)
		{
			//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_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_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_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_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_00b8: 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)
			if (Fly.CanFly && Fly.isFlying)
			{
				Keyboard current = Keyboard.current;
				bool flag = MysteryDice.Keybinds.FlyButton.ReadValue<float>() > 0.5f;
				bool flag2 = MysteryDice.Keybinds.FlyDownButton.ReadValue<float>() > 0.5f;
				float num = 8f;
				Vector3 zero = Vector3.zero;
				zero = (flag ? (((Component)__instance).transform.up * num) : ((!flag2) ? Vector3.zero : (-((Component)__instance).transform.up * num)));
				__instance.externalForces = new Vector3(__instance.externalForces.x, zero.y, __instance.externalForces.z);
				__instance.fallValue = 0f;
				__instance.ResetFallGravity();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void BreakNeckUpdate(PlayerControllerB __instance)
		{
			//IL_0055: 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_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_009b: 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_00b5: 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_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)
			if (NeckBreak.IsNeckBroken != 0)
			{
				Transform transform = ((Component)GameNetworkManager.Instance.localPlayerController.gameplayCamera).transform;
				switch (NeckBreak.IsNeckBroken)
				{
				case 0:
					return;
				case 1:
					transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, 90f);
					break;
				case 2:
					transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, 180f);
					break;
				case 3:
					transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, -90f);
					break;
				case 4:
					transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, 0f);
					NeckBreak.IsNeckBroken = 0;
					break;
				default:
					NeckBreak.IsNeckBroken = 0;
					break;
				}
				if (MysteryDice.useNeckBreakTimer.Value && !NeckBreak.isTimerRunning)
				{
					((MonoBehaviour)Networker.Instance).StartCoroutine(NeckBreak.WaitTime());
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void HyperShakeUpdate()
		{
			if (HyperShake.ShakingData != null && MysteryDice.hyperShakeTimer.Value > 0 && !HyperShake.isTimerRunning)
			{
				((MonoBehaviour)Networker.Instance).StartCoroutine(HyperShake.WaitTime());
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void NeckSpinUpdate(PlayerControllerB __instance)
		{
			//IL_0039: 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_00d0: 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_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_0118: 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_014c: 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 (NeckSpin.IsNeckSpinning == 0)
			{
				return;
			}
			Transform transform = ((Component)GameNetworkManager.Instance.localPlayerController.gameplayCamera).transform;
			if (__instance.isClimbingLadder)
			{
				NeckSpin.counter = 0;
				NeckSpin.savedValue = transform.eulerAngles.z;
				NeckSpin.wasClimbing = true;
				return;
			}
			if (NeckSpin.wasClimbing)
			{
				if (NeckSpin.counter >= 50)
				{
					NeckSpin.wasClimbing = false;
				}
				NeckSpin.counter++;
				transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, NeckSpin.savedValue);
				return;
			}
			transform.eulerAngles += new Vector3(0f, 0f, NeckSpin.neckChoiceSpeed * Time.deltaTime);
			if (MysteryDice.neckRotations.Value != -1)
			{
				if (MysteryDice.neckRotations.Value == NeckSpin.rotationNumber)
				{
					NeckSpin.FixNeck();
					NeckSpin.IsNeckSpinning = 0;
				}
				if (transform.eulerAngles.z >= 359f)
				{
					NeckSpin.rotationNumber++;
					transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, 0f);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		public static void MartyrdomPlayer(PlayerControllerB __instance, int causeOfDeath, int deathAnimation, bool spawnBody, Vector3 bodyVelocity)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (Martyrdom.doMinesDrop)
			{
				Networker.Instance.doMartyrdomServerRPC(((Component)__instance).transform.position);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
	public static class JumpPerformedPatch
	{
		[HarmonyPrefix]
		public static void JumpPerformedPrefix(CallbackContext context, PlayerControllerB __instance)
		{
			if (EggBoots.eggBootsEnabled && EggBoots.canSpawnAnother)
			{
				EggBoots.canSpawnAnother = false;
				Networker.Instance.spawnExplodeEggServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch
	{
		public static List<Vector3> MapObjectsPositions = new List<Vector3>();

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void StartRoundManager(RoundManager __instance)
		{
		}

		[HarmonyPrefix]
		[HarmonyPatch("SpawnMapObjects")]
		public static void SpawnMapObjectsPatch(RoundManager __instance)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.currentLevel.spawnableMapObjects.Length != 0)
			{
				Random random = new Random(StartOfRound.Instance.randomMapSeed + 587);
				__instance.mapPropsContainer = GameObject.FindGameObjectWithTag("MapPropsContainer");
				RandomMapObject[] array = Object.FindObjectsOfType<RandomMapObject>();
				RandomMapObject[] array2 = array;
				foreach (RandomMapObject val in array2)
				{
					MapObjectsPositions.Add(((Component)val).transform.position);
				}
			}
		}
	}
	[HarmonyPatch(typeof(SandSpiderAI))]
	internal class SpiderPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		public static void IncreaseSpeed(SandSpiderAI __instance)
		{
			if (Arachnophobia.IsEnabled)
			{
				__instance.spiderSpeed = 12f;
				((EnemyAI)__instance).agent.speed = 12f;
				((EnemyAI)__instance).creatureAnimator.speed = 7f;
				__instance.MoveLegsProcedurally();
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void InstantiateNetworker(StartOfRound __instance)
		{
			//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)
			MysteryDice.JumpscareOBJ = Object.Instantiate<GameObject>(MysteryDice.JumpscareCanvasPrefab);
			MysteryDice.JumpscareScript = MysteryDice.JumpscareOBJ.GetComponent<Jumpscare>();
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				if ((Object)(object)Networker.Instance == (Object)null)
				{
					GameObject val = Object.Instantiate<GameObject>(MysteryDice.NetworkerPrefab, Vector3.zero, Quaternion.identity);
					val.GetComponent<NetworkObject>().Spawn(false);
				}
				else
				{
					MysteryDice.CustomLogger.LogError((object)"Networker already exists??????");
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("StartGame")]
		public static void OnStartGame(StartOfRound __instance)
		{
			GetEnemies.allEnemies = Resources.FindObjectsOfTypeAll<EnemyType>().ToList();
			if (((NetworkBehaviour)Networker.Instance).IsServer)
			{
				if (MysteryDice.LoversOnStart.Value && ((NetworkBehaviour)StartOfRound.Instance).IsHost)
				{
					new Lovers().Use();
				}
				Networker.Instance.OnStartRoundClientRPC();
				ResetSettingsShared();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("StartGame")]
		public static void BrutalStart(StartOfRound __instance)
		{
			if (!((NetworkBehaviour)Networker.Instance).IsServer || !MysteryDice.BrutalMode.Value)
			{
				return;
			}
			int num = Networker.Instance.CheckScaling();
			for (int i = 0; i < num; i++)
			{
				if (MysteryDice.SuperBrutalMode.Value)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(waitForBrutal());
				}
				else
				{
					Networker.Instance.QueueRandomDiceEffectServerRPC("Brutal");
				}
			}
		}

		public static IEnumerator waitForBrutal()
		{
			yield return (object)new WaitForSeconds(Random.Range(30f, 600f));
			Networker.Instance.QueueRandomDiceEffectServerRPC("Brutal");
		}

		public static void StartGameOnClient()
		{
			if (!((NetworkBehaviour)Networker.Instance).IsServer)
			{
				ResetSettingsShared();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("EndGameClientRpc")]
		public static void OnEndGameClient(StartOfRound __instance)
		{
			ResetSettingsShared();
			Lovers.removeLovers();
		}

		[HarmonyPostfix]
		[HarmonyPatch("EndGameServerRpc")]
		public static void OnEndGameServer(StartOfRound __instance)
		{
			ResetSettingsShared();
		}

		[HarmonyPostfix]
		[HarmonyPatch("ShipHasLeft")]
		public static void OnEndShipHasLeft(StartOfRound __instance)
		{
			ResetSettingsShared();
			CursedStuff();
		}

		public static void CursedStuff()
		{
			if (!MysteryDice.cursedRandomly.Value || TimeOfDay.Instance.daysUntilDeadline != 0)
			{
				return;
			}
			string body = string.Join(", ", Networker.Instance.cursedPeople.Select((ulong id) => Misc.getPlayerBySteamID(id)?.playerUsername ?? "Unknown"));
			Misc.SafeTipMessage("Cursed Players last round:", body);
			if (!((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				return;
			}
			Networker.Instance.cursedPeople.Clear();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (Misc.IsPlayerReal(val) && Random.value < 0.25f)
				{
					Networker.Instance.cursedPeople.Add(val.playerSteamId);
				}
			}
			Networker.Instance.SyncCursedPlayersClientRpc(Networker.Instance.cursedPeople.ToArray());
		}

		public static void ResetSettingsShared()
		{
			//IL_0090: 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)
			FireExitPatch.AreFireExitsBlocked = false;
			Networker.CoilheadIgnoreStares = false;
			RebeliousCoilHeads.IsEnabled = false;
			Arachnophobia.IsEnabled = false;
			ModifyPitch.ResetPitch();
			Armageddon.IsEnabled = false;
			AlarmCurse.IsCursed = false;
			TurretPatch.FastCharging = false;
			BrightFlashlight.IsEnabled = false;
			PlayerControllerBPatch.HasInfiniteStamina = false;
			HyperShake.ShakingData = null;
			IHearDeadPeople.isSixthSensed = false;
			EggBoots.eggBootsEnabled = false;
			Martyrdom.doMinesDrop = false;
			Confusion.isConfused = false;
			Lizard.isRunning = false;
			Networker.Instance.resetAudioPlaces();
			Networker.Instance.MimicTrackers.Clear();
			if (LeverShake.IsShaking)
			{
				LeverShake.ShipLeverTrigger.transform.localPosition = LeverShake.InitialLevelTriggerLocalPosition;
				LeverShake.ShipLever.transform.localPosition = LeverShake.InitialLevelTriggerLocalPosition;
			}
			LeverShake.IsShaking = false;
			LeverShake.ShipLeverTrigger = null;
			Fly.CanFly = false;
			SelectEffect.CloseSelectMenu();
			NeckBreak.FixNeck();
			NeckSpin.FixNeck();
			TimeOfDay.Instance.overrideMeteorChance = -1;
			TimeOfDay.Instance.meteorShowerAtTime = -1f;
			Meteors.isRunning = false;
			try
			{
				((MonoBehaviour)Networker.Instance).StopAllCoroutines();
				if (((NetworkBehaviour)Networker.Instance).IsServer)
				{
					Networker.Instance.SyncRateClientRPC(StartOfRound.Instance.companyBuyingRate);
				}
			}
			catch (Exception ex)
			{
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("This happened but is nothing to worry about I believe: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal class TerminalPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		public static void TerminalStart(Terminal __instance)
		{
			AddDiceSynonym("emergencydie");
			AddDiceSynonym("dice");
			AddDiceSynonym("die");
			AddDiceSynonym("edie");
		}

		public static void AddDiceSynonym(string synonym)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			TerminalKeyword keyword = GetKeyword("emergency-die");
			if ((Object)(object)keyword == (Object)null || (Object)(object)GetKeyword(synonym) != (Object)null)
			{
				return;
			}
			TerminalKeyword val = ScriptableObject.CreateInstance<TerminalKeyword>();
			val.isVerb = keyword.isVerb;
			val.defaultVerb = keyword.defaultVerb;
			val.compatibleNouns = keyword.compatibleNouns;
			val.specialKeywordResult = keyword.specialKeywordResult;
			val.accessTerminalObjects = keyword.accessTerminalObjects;
			val.word = synonym;
			Items.terminal.terminalNodes.allKeywords = CollectionExtensions.AddItem<TerminalKeyword>((IEnumerable<TerminalKeyword>)Items.terminal.terminalNodes.allKeywords, val).ToArray();
			for (int i = 0; i < Items.terminal.terminalNodes.allKeywords.Length; i++)
			{
				TerminalKeyword val2 = Items.terminal.terminalNodes.allKeywords[i];
				if (val2.word == "buy")
				{
					CompatibleNoun diceCompatibleNoun = GetDiceCompatibleNoun();
					CompatibleNoun val3 = new CompatibleNoun(val, diceCompatibleNoun.result);
					val2.compatibleNouns = CollectionExtensions.AddItem<CompatibleNoun>((IEnumerable<CompatibleNoun>)val2.compatibleNouns, val3).ToArray();
					break;
				}
			}
		}

		public static TerminalKeyword GetKeyword(string keyword)
		{
			TerminalKeyword[] allKeywords = Items.terminal.terminalNodes.allKeywords;
			foreach (TerminalKeyword val in allKeywords)
			{
				if (val.word == keyword)
				{
					return val;
				}
			}
			return null;
		}

		public static CompatibleNoun GetDiceCompatibleNoun()
		{
			TerminalKeyword[] allKeywords = Items.terminal.terminalNodes.allKeywords;
			foreach (TerminalKeyword val in allKeywords)
			{
				if (!(val.word == "buy"))
				{
					continue;
				}
				CompatibleNoun[] compatibleNouns = val.compatibleNouns;
				foreach (CompatibleNoun val2 in compatibleNouns)
				{
					if (val2.noun.word == "emergency-die")
					{
						return val2;
					}
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class TimeOfDayPatch
	{
		public static float AdditionalBuyingRate;

		[HarmonyPostfix]
		[HarmonyPatch("SetBuyingRateForDay")]
		public static void BuyingRateMod(TimeOfDay __instance)
		{
			StartOfRound instance = StartOfRound.Instance;
			instance.companyBuyingRate += AdditionalBuyingRate;
			if (!((Object)(object)Networker.Instance == (Object)null) && ((NetworkBehaviour)Networker.Instance).IsServer)
			{
				Networker.Instance.SyncRateClientRPC(StartOfRound.Instance.companyBuyingRate);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetNewProfitQuota")]
		public static void OnNewProfitQuota(TimeOfDay __instance)
		{
			AdditionalBuyingRate = 0f;
		}
	}
	[HarmonyPatch(typeof(Turret))]
	internal class TurretPatch
	{
		public static bool FastCharging;

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static bool ForceFastShooting(Turret __instance, ref float ___turretInterval, TurretMode ___turretMode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)___turretMode == 1 && FastCharging)
			{
				___turretInterval = 100f;
			}
			return true;
		}
	}
	public class UnlockableSuitPatch
	{
		[HarmonyPatch(typeof(UnlockableSuit), "SwitchSuitForPlayer")]
		public class Patch_DisableSuitAudio
		{
			private static void Prefix(ref bool playAudio)
			{
				if (Confusion.isConfused)
				{
					playAudio = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "UpdatePlayerVoiceEffects")]
	internal static class ChangeVoices_ApplyPatch
	{
		private static void Postfix(StartOfRound __instance)
		{
			if (!IHearDeadPeople.isSixthSensed || __instance?.allPlayerScripts == null)
			{
				return;
			}
			PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
			PlayerControllerB[] allPlayerScripts = __instance.allPlayerScripts;
			foreach (PlayerControllerB val2 in allPlayerScripts)
			{
				MysteryDice.ExtendedLogging("test", (LogLevel)16);
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2 == (Object)(object)val || !val2.isPlayerDead || !Misc.IsPlayerReal(val2))
				{
					continue;
				}
				AudioSource currentVoiceChatAudioSource = val2.currentVoiceChatAudioSource;
				if (!((Object)(object)currentVoiceChatAudioSource == (Object)null))
				{
					currentVoiceChatAudioSource.spatialBlend = 1f;
					if ((Object)(object)val2.currentVoiceChatIngameSettings != (Object)null)
					{
						val2.currentVoiceChatIngameSettings.set2D = false;
					}
					val2.voicePlayerState.Volume = 1f;
					currentVoiceChatAudioSource.volume = 1f;
				}
			}
		}
	}
}
namespace MysteryDice.MiscStuff
{
	public class Consts
	{
		public const string Default = "Default";

		public const string Experimentation = "Experimentation";

		public const string Assurance = "Assurance";

		public const string Vow = "Vow";

		public const string Offense = "Offense";

		public const string March = "March";

		public const string Rend = "Rend";

		public const string Dine = "Dine";

		public const string Titan = "Titan";

		public const string Adamance = "Adamance";

		public const string Artifice = "Artifice";

		public const string Embrion = "Embrion";
	}
	public class CustomEnemyConfig
	{
		public string monsterName { get; set; }

		public EffectType outcome { get; set; }

		public bool IsInside { get; set; }

		public int AmountMin { get; set; }

		public int AmountMax { get; set; }

		public string customName { get; set; }

		public string customTooltip { get; set; }
	}
	public class CustomItemConfig
	{
		public string itemName { get; set; }

		public EffectType outcome { get; set; }

		public int AmountMax { get; set; }

		public string customName { get; set; }

		public string customTooltip { get; set; }
	}
	public class CustomTrapConfig
	{
		public string trapName { get; set; }

		public EffectType outcome { get; set; }

		public bool IsInside { get; set; }

		public int AmountMax { get; set; }

		public bool moving { get; set; }

		public string customName { get; set; }

		public string customTooltip { get; set; }
	}
	public class CustomConfigs
	{
		private ConfigFile configFile;

		public List<CustomEnemyConfig> EnemyConfigs { get; private set; } = new List<CustomEnemyConfig>();

		public List<CustomItemConfig> ItemConfigs { get; private set; } = new List<CustomItemConfig>();

		public List<CustomTrapConfig> TrapConfigs { get; private set; } = new List<CustomTrapConfig>();

		public CustomConfigs(ConfigFile config)
		{
			configFile = config;
		}

		public void GenerateConfigs(int numberOfEnemyConfigs, int numberOfItemConfigs, int numberOfTrapConfigs)
		{
			for (int i = 1; i <= numberOfEnemyConfigs; i++)
			{
				string value = configFile.Bind<string>($"CustomEnemy{i}", "Monster Name", "Locker", $"The name of Custom Enemy{i}\nMake sure to get the EXACT name of the enemy\nYou can use the DebugLogging config and go to a moon to see all enemy names").Value;
				string value2 = configFile.Bind<string>($"CustomEnemy{i}", "Enemy Display Name", "School Season", "Sets the Display name \"Player Rolled Item Display Name\"").Value;
				string value3 = configFile.Bind<string>($"CustomEnemy{i}", "Enemy Tooltip Name", "Don't scan them!", "This is the Tooltip that shows on the popup for the dice").Value;
				bool value4 = configFile.Bind<bool>($"CustomEnemy{i}", "Is Inside", false, $"Does the enemy Spawn inside for Custom{i}").Value;
				EffectType value5 = configFile.Bind<EffectType>($"CustomEnemy{i}", "Outcome", EffectType.Bad, $"Sets the Outcome for Custom{i}").Value;
				int value6 = configFile.Bind<int>($"CustomEnemy{i}", "Amount Min", 1, $"Minimum number of enemies to spawn for Custom{i}").Value;
				int value7 = configFile.Bind<int>($"CustomEnemy{i}", "Amount Max", 5, $"Maximum number of enemies to spawn for Custom{i}").Value;
				CustomEnemyConfig customEnemyConfig = new CustomEnemyConfig
				{
					monsterName = value,
					outcome = value5,
					IsInside = value4,
					AmountMin = value6,
					AmountMax = value7,
					customName = value2,
					customTooltip = value3
				};
				EnemyConfigs.Add(customEnemyConfig);
				DieBehaviour.AllEffects.Add(new DynamicEffect(value2 ?? "", customEnemyConfig));
			}
			for (int j = 1; j <= numberOfItemConfigs; j++)
			{
				string value8 = configFile.Bind<string>($"CustomItem{j}", "Item Name", "Key", $"The name of Item{j}\nMake sure to get the EXACT name of the Item\nYou can use the DebugLogging config and pick up the item to see it's name").Value;
				string value9 = configFile.Bind<string>($"CustomItem{j}", "Item Display Name", "Door Opener", "Sets the Display name \"Player Rolled Item Display Name\"").Value;
				string value10 = configFile.Bind<string>($"CustomItem{j}", "Item Tooltip Name", "They Open Doors!", "This is the Tooltip that shows on the popup for the dice").Value;
				EffectType value11 = configFile.Bind<EffectType>($"CustomItem{j}", "Outcome", EffectType.Good, $"Sets the Outcome for Custom{j}").Value;
				int value12 = configFile.Bind<int>($"CustomItem{j}", "Amount Max", 5, $"Maximum number of Items to spawn for Custom{j}").Value;
				CustomItemConfig customItemConfig = new CustomItemConfig
				{
					itemName = value8,
					outcome = value11,
					AmountMax = value12,
					customName = value9,
					customTooltip = value10
				};
				ItemConfigs.Add(customItemConfig);
				DieBehaviour.AllEffects.Add(new DynamicItemEffect(value9 ?? "", customItemConfig));
			}
			for (int k = 1; k <= numberOfTrapConfigs; k++)
			{
				string value13 = configFile.Bind<string>($"CustomTrap{k}", "Trap Name", "CageMine", $"The name of Trap{k}\nMake sure to get the EXACT name of the Trap\nYou can use the DebugLogging config and go to a moon to see all SpawnableMapObjects names").Value;
				string value14 = configFile.Bind<string>($"CustomTrap{k}", "Trap Display Name", "Cage Mines?", "Sets the Display name \"Player Rolled Trap Display Name\"").Value;
				string value15 = configFile.Bind<string>($"CustomTrap{k}", "Trap Tooltip Name", "It's Gonna Trap Ya", "This is the Tooltip that shows on the popup for the dice").Value;
				bool value16 = configFile.Bind<bool>($"CustomTrap{k}", "Is Inside", false, $"Does the Trap Spawn inside for Custom{k}").Value;
				EffectType value17 = configFile.Bind<EffectType>($"CustomTrap{k}", "Outcome", EffectType.Awful, $"Sets the Outcome for Custom{k}").Value;
				int value18 = configFile.Bind<int>($"CustomTrap{k}", "Amount Max", 5, $"Maximum number of Traps to spawn for Custom{k}").Value;
				bool value19 = configFile.Bind<bool>($"CustomTrap{k}", "Moving", false, $"Do traps of the type: {k} move").Value;
				CustomTrapConfig customTrapConfig = new CustomTrapConfig
				{
					trapName = value13,
					outcome = value17,
					IsInside = value16,
					moving = value19,
					AmountMax = value18,
					customName = value14,
					customTooltip = value15
				};
				TrapConfigs.Add(customTrapConfig);
				MysteryDice.MainRegisterNewEffect(new DynamicTrapEffect(value14 ?? "", customTrapConfig));
			}
		}
	}
	internal class DynamicEffect : IEffect
	{
		private string name;

		private CustomEnemyConfig config;

		public static EnemyType enemy;

		public string Name => name;

		public EffectType Outcome => config.outcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => config.customTooltip;

		public DynamicEffect(string name, CustomEnemyConfig config)
		{
			this.name = name;
			this.config = config;
		}

		public void Use()
		{
			Networker.Instance.CustomMonsterServerRPC(config.monsterName, config.AmountMin, config.AmountMax, config.IsInside);
		}

		public static void spawnEnemy(string names, int min, int max, bool inside, Vector3 size = default(Vector3))
		{
			string[] array = names.Split(',');
			string[] array2 = array;
			foreach (string name in array2)
			{
				int num = 0;
				List<EnemyType> source = GetEnemies.allEnemies.OrderBy((EnemyType x) => x.enemyName).ToList();
				enemy = ((IEnumerable<EnemyType>)source).FirstOrDefault((Func<EnemyType, bool>)((EnemyType x) => x.enemyName == name));
				if ((Object)(object)enemy == (Object)null)
				{
					MysteryDice.CustomLogger.LogWarning((object)("Enemy '" + name + "' not found. Available enemies: " + string.Join(", ", source.Select((EnemyType e) => e.enemyName))));
					break;
				}
				num = Random.Range(min, max + 1);
				Misc.SpawnEnemy(enemy, num, inside);
			}
		}
	}
	internal class DynamicItemEffect : IEffect
	{
		private string name;

		private CustomItemConfig config;

		public string Name => name;

		public EffectType Outcome => config.outcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => config.customTooltip;

		public DynamicItemEffect(string name, CustomItemConfig config)
		{
			this.name = name;
			this.config = config;
		}

		public void Use()
		{
			//IL_0040: 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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(1, config.AmountMax + 1), config.itemName);
		}
	}
	internal class DynamicTrapEffect : IEffect
	{
		private string name;

		private CustomTrapConfig config;

		public string Name => name;

		public EffectType Outcome => config.outcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => config.customTooltip;

		public DynamicTrapEffect(string name, CustomTrapConfig config)
		{
			this.name = name;
			this.config = config;
		}

		public void Use()
		{
			Networker.Instance.CustomTrapServerRPC(config.AmountMax, config.trapName, config.IsInside, config.moving);
		}

		public static trap getTrap(string name)
		{
			trap[] allTraps = Misc.getAllTraps();
			trap trap = allTraps.FirstOrDefault((trap x) => x.name == name);
			if (trap == null)
			{
				trap = allTraps.FirstOrDefault((trap x) => x.name == "Landmine");
			}
			return trap;
		}

		public unsafe static void spawnTrap(int max, string trapNames, bool inside, float positionOffsetRadius = 5f, bool moving = false, bool useScale = false, Vector3 scale = default(Vector3))
		{
			//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_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_0123: 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_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_015b: 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_0182: 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_01a1: 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_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_0215: 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)
			string[] array = trapNames.Split(',');
			string[] array2 = array;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			foreach (string text in array2)
			{
				List<Vector3> list = new List<Vector3>();
				int num = 0;
				Random random = new Random(StartOfRound.Instance.randomMapSeed);
				List<GameObject> list2 = (inside ? RoundManager.Instance.insideAINodes.ToList() : RoundManager.Instance.outsideAINodes.ToList());
				int count = list2.Count;
				if (count == 0)
				{
					break;
				}
				int num2 = 100;
				trap trap = getTrap(text);
				int num3 = Random.Range(3, max + 1);
				while (num < num3)
				{
					for (int j = 0; j < count; j++)
					{
						if (num >= num3)
						{
							break;
						}
						Vector3 position = list2[Random.Range(0, count)].transform.position;
						bool flag = false;
						for (int k = 0; k < num2; k++)
						{
							if (flag)
							{
								break;
							}
							((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
							Vector3 val2 = position + val;
							if (!Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
							{
								continue;
							}
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, list) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(trap.prefab, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								list.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								NetworkObject component = val4.GetComponent<NetworkObject>();
								component.Spawn(true);
								num++;
								if (useScale)
								{
									Networker.Instance.setSizeClientRPC(component.NetworkObjectId, scale, Quaternion.identity);
								}
							}
						}
						if (!flag)
						{
							Vector3 val5 = position;
							Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
						}
					}
				}
				if (num > 0 && moving)
				{
					Networker.Instance.AddMovingTrapClientRPC(trap.name);
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	[RequireComponent(typeof(NavMeshAgent))]
	public class SmartAgentNavigator : NetworkBehaviour
	{
		[HideInInspector]
		public bool cantMove;

		[HideInInspector]
		public EntranceTeleport lastUsedEntranceTeleport;

		[HideInInspector]
		public NavMeshAgent agent = null;

		[HideInInspector]
		public bool isOutside = true;

		[HideInInspector]
		public List<EntranceTeleport> exitPoints = new List<EntranceTeleport>();

		[HideInInspector]
		public EntranceTeleport? mainEntrance;

		private readonly float nonAgentMovementSpeed = 10f;

		private Coroutine? checkPathsRoutine;

		private MineshaftElevatorController? elevatorScript;

		private bool inElevator;

		[HideInInspector]
		public UnityEvent<bool> OnEnableOrDisableAgent = new UnityEvent<bool>();

		[HideInInspector]
		public UnityEvent<bool> OnEnterOrExitElevator = new UnityEvent<bool>();

		[HideInInspector]
		public UnityEvent<bool> OnUseEntranceTeleport = new UnityEvent<bool>();

		[HideInInspector]
		public PathfindingOperation? pathfindingOperation;

		private Vector3 pointToGo = Vector3.zero;

		private bool usingElevator;

		[SerializeField]
		private float _nodeRemovalPrecision = 5f;

		private Coroutine? _searchRoutine;

		private float _searchRadius = 50f;

		private readonly List<Vector3> _positionsToSearch = new List<Vector3>();

		private readonly List<(Vector3 nodePosition, Vector3 position)> _roamingPointsVectorList = new List<(Vector3, Vector3)>();

		public void Awake()
		{
			agent = ((Component)this).gameObject.GetComponent<NavMeshAgent>();
		}

		public void SetAllValues(bool isOutside)
		{
			this.isOutside = isOutside;
			exitPoints.Clear();
			foreach (EntranceTeleport entrancePoint in Networker.EntrancePoints)
			{
				exitPoints.Add(entrancePoint);
				if (entrancePoint.entranceId == 0 && entrancePoint.isEntranceToBuilding)
				{
					mainEntrance = entrancePoint;
				}
			}
			elevatorScript = RoundManager.Instance.currentMineshaftElevator;
		}

		public void ResetAllValues()
		{
			exitPoints.Clear();
			elevatorScript = null;
			mainEntrance = null;
		}

		public void StopAgent()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (((Behaviour)agent).enabled && agent.isOnNavMesh)
			{
				agent.ResetPath();
			}
			agent.velocity = Vector3.zero;
		}

		public bool DoPathingToDestination(Vector3 destination)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (_searchRoutine != null)
			{
				StopSearchRoutine();
			}
			if (cantMove)
			{
				return false;
			}
			if (!((Behaviour)agent).enabled)
			{
				HandleDisabledAgentPathing();
				return false;
			}
			return GoToDestination(destination);
		}

		public bool CheckPathsOngoing()
		{
			return checkPathsRoutine != null;
		}

		public void CheckPaths<T>(IEnumerable<(T, Vector3)> points, Action<List<(T, float)>> action)
		{
			if (CheckPathsOngoing())
			{
				((MonoBehaviour)this).StopCoroutine(checkPathsRoutine);
				checkPathsRoutine = null;
				ClearPathfindingOperation();
			}
			checkPathsRoutine = ((MonoBehaviour)this).StartCoroutine(CheckPathsCoroutine(points, action));
		}

		private IEnumerator CheckPathsCoroutine<T>(IEnumerable<(T, Vector3)> points, Action<List<(T, float)>> action)
		{
			MysteryDice.ExtendedLogging($"Checking paths for {points.Count()} objects", (LogLevel)16);
			List<(T, float)> TList = new List<(T, float)>();
			ClearPathfindingOperation();
			(T, Vector3)[] array = points.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				(T, Vector3) tuple = array[i];
				T obj = tuple.Item1;
				Vector3 point = tuple.Item2;
				bool pathFound = false;
				float bestDistance = float.MaxValue;
				EntranceTeleport entranceTeleport;
				while (!TryFindViablePath(point, out pathFound, out bestDistance, out entranceTeleport))
				{
					yield return null;
				}
				if (pathFound)
				{
					TList.Add((obj, bestDistance));
				}
			}
			ClearPathfindingOperation();
			action(TList);
			checkPathsRoutine = null;
		}

		private void HandleDisabledAgentPathing()
		{
			//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_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_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_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_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_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_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_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_00d5: 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)
			Vector3 val = pointToGo;
			float num = 10f;
			float num2 = Vector3.Distance(((Component)this).transform.position, val);
			if (Vector3.Distance(((Component)this).transform.position, val) <= 1f)
			{
				OnEnableOrDisableAgent.Invoke(true);
				((Behaviour)agent).enabled = true;
				agent.Warp(val);
			}
			else
			{
				float num3 = Mathf.Clamp01(Vector3.Distance(((Component)this).transform.position, val) / num2);
				Vector3 val2 = Vector3.MoveTowards(((Component)this).transform.position, val, Time.deltaTime * nonAgentMovementSpeed);
				val2.y += Mathf.Sin(num3 * MathF.PI) * num;
				((Component)this).transform.SetPositionAndRotation(val2, Quaternion.LookRotation(val - ((Component)this).transform.position));
			}
		}

		private bool DetermineIfNeedToDisableAgent(Vector3 destination)
		{
			//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_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)
			//IL_0067: 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_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_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_00ce: 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)
			float num = Vector3.Distance(((Component)this).transform.position, destination);
			if (num <= agent.stoppingDistance + 5f)
			{
				return false;
			}
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.SamplePosition(destination, ref val, 3f, agent.areaMask))
			{
				return false;
			}
			Vector3 val2 = FindClosestValidPoint();
			agent.SetDestination(val2);
			if (Vector3.Distance(((Component)agent).transform.position, val2) <= agent.stoppingDistance)
			{
				pointToGo = ((NavMeshHit)(ref val)).position;
				OnEnableOrDisableAgent.Invoke(false);
				((Behaviour)agent).enabled = false;
				MysteryDice.ExtendedLogging($"Pathing to initial destination {destination} failed, going to fallback position {((NavMeshHit)(ref val)).position} instead.", (LogLevel)16);
				return true;
			}
			return false;
		}

		public float CanPathToPoint(Vector3 startPos, Vector3 endPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_0057: 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)
			NavMeshPath val = new NavMeshPath();
			if (!NavMesh.CalculatePath(startPos, endPos, -1, val) || (int)val.status > 0)
			{
				return -1f;
			}
			float num = 0f;
			if (val.corners.Length > 1)
			{
				for (int i = 1; i < val.corners.Length; i++)
				{
					num += Vector3.Distance(val.corners[i - 1], val.corners[i]);
				}
			}
			return num;
		}

		public void ClearPathfindingOperation()
		{
			pathfindingOperation?.Dispose();
			pathfindingOperation = null;
		}

		internal T ChangePathfindingOperation<T>(Func<T> provider) where T : PathfindingOperation
		{
			PathfindingOperation? obj = pathfindingOperation;
			if (obj != null && obj.HasDisposed())
			{
				pathfindingOperation = null;
			}
			T val = pathfindingOperation as T;
			if (val == null)
			{
				val = provider();
				pathfindingOperation?.Dispose();
				pathfindingOperation = val;
			}
			return val;
		}

		public bool TryFindViablePath(Vector3 endPosition, out bool foundPath, out float bestDistance, out EntranceTeleport? entranceTeleport)
		{
			//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)
			FindPathThroughTeleportsOperation findPathThroughTeleportsOperation = ChangePathfindingOperation(() => new FindPathThroughTeleportsOperation(exitPoints, AgentExtensions.GetPathOrigin(agent), endPosition, agent));
			return findPathThroughTeleportsOperation.TryGetShortestPath(out foundPath, out bestDistance, out entranceTeleport);
		}

		public bool GoToDestination(Vector3 actualEndPosition)
		{
			//IL_0002: 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_0044: 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_00d1: 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_0090: 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)
			if (TryFindViablePath(actualEndPosition, out bool foundPath, out float _, out EntranceTeleport entranceTeleport))
			{
				if ((Object)(object)entranceTeleport == (Object)null && !foundPath)
				{
					if ((Object)(object)elevatorScript != (Object)null)
					{
						if (NeedsElevator(actualEndPosition, elevatorScript, out var goingUp))
						{
							usingElevator = true;
							HandleElevatorActions(elevatorScript, goingUp);
							return false;
						}
						if (!elevatorScript.elevatorFinishedMoving && Vector3.Distance(actualEndPosition, elevatorScript.elevatorInsidePoint.position) < 7f)
						{
							return false;
						}
					}
					if ((isOutside && actualEndPosition.y > -50f) || (!isOutside && actualEndPosition.y < -50f))
					{
						DetermineIfNeedToDisableAgent(actualEndPosition);
						return false;
					}
					if ((Object)(object)mainEntrance == (Object)null)
					{
						return false;
					}
					DoPathingThroughEntrance(mainEntrance);
					return false;
				}
				if ((Object)(object)entranceTeleport == (Object)null)
				{
					agent.SetDestination(actualEndPosition);
					return true;
				}
				DoPathingThroughEntrance(entranceTeleport);
				return false;
			}
			return false;
		}

		private void HandleElevatorActions(MineshaftElevatorController elevatorScript, bool goingUp)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (inElevator)
			{
				agent.Warp(elevatorScript.elevatorInsidePoint.position);
			}
			else
			{
				UseTheElevator(elevatorScript, goingUp);
			}
		}

		private void DoPathingThroughEntrance(EntranceTeleport viableEntrance)
		{
			//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_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_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_0079: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = viableEntrance.entrancePoint.position;
			Vector3 position2 = viableEntrance.exitScript.entrancePoint.position;
			float num = Vector3.Distance(((Component)this).transform.position, position);
			if (num <= agent.stoppingDistance + 1f)
			{
				agent.Warp(position2);
				SetThingOutsideServerRpc(!isOutside, new NetworkBehaviourReference((NetworkBehaviour)(object)viableEntrance));
			}
			else
			{
				agent.SetDestination(position);
			}
		}

		private bool NeedsElevator(Vector3 destination, MineshaftElevatorController elevatorScript, out bool goingUp)
		{
			//IL_000c: 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_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_0050: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			goingUp = false;
			if (isOutside && destination.y > -50f)
			{
				usingElevator = false;
				return false;
			}
			if (usingElevator)
			{
				return true;
			}
			bool flag = Vector3.Distance(destination, RoundManager.FindMainEntrancePosition(true, false)) < Vector3.Distance(destination, elevatorScript.elevatorBottomPoint.position);
			bool flag2 = Vector3.Distance(((Component)this).transform.position, elevatorScript.elevatorTopPoint.position) > 15f;
			goingUp = flag;
			return (flag && flag2) || (!flag2 && !flag);
		}

		private void UseTheElevator(MineshaftElevatorController elevatorScript, bool goingUp)
		{
			//IL_0047: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			MoveToWaitingPoint(elevatorScript, goingUp);
			if (elevatorScript.elevatorFinishedMoving && elevatorScript.elevatorDoorOpen)
			{
				if (NeedToCallElevator(elevatorScript, goingUp))
				{
					elevatorScript.CallElevatorOnServer(goingUp);
				}
				else if (Vector3.Distance(((Component)this).transform.position, elevatorScript.elevatorInsidePoint.position) > 1f)
				{
					agent.SetDestination(elevatorScript.elevatorInsidePoint.position);
				}
				else if (!inElevator)
				{
					elevatorScript.PressElevatorButtonOnServer(true);
					((MonoBehaviour)this).StartCoroutine(StopUsingElevator(elevatorScript));
				}
			}
		}

		private IEnumerator StopUsingElevator(MineshaftElevatorController elevatorScript)
		{
			inElevator = true;
			OnEnterOrExitElevator.Invoke(true);
			yield return (object)new WaitForSeconds(2f);
			yield return (object)new WaitUntil((Func<bool>)(() => elevatorScript.elevatorDoorOpen && elevatorScript.elevatorFinishedMoving));
			MysteryDice.ExtendedLogging("Stopped using elevator", (LogLevel)16);
			usingElevator = false;
			OnEnterOrExitElevator.Invoke(false);
			inElevator = false;
		}

		private bool NeedToCallElevator(MineshaftElevatorController elevatorScript, bool needToGoUp)
		{
			return !elevatorScript.elevatorCalled && ((!elevatorScript.elevatorIsAtBottom && needToGoUp) || (elevatorScript.elevatorIsAtBottom && !needToGoUp));
		}

		private void MoveToWaitingPoint(MineshaftElevatorController elevatorScript, bool needToGoUp)
		{
			//IL_0007: 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_005f: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			if (Vector3.Distance(((Component)this).transform.position, elevatorScript.elevatorInsidePoint.position) > 1f)
			{
				agent.SetDestination(needToGoUp ? elevatorScript.elevatorBottomPoint.position : elevatorScript.elevatorTopPoint.position);
			}
			else
			{
				agent.SetDestination(elevatorScript.elevatorInsidePoint.position);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetThingOutsideServerRpc(bool setOutside, NetworkBehaviourReference entranceTeleportReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0098: 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_00b2: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2821486977u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref setOutside, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkBehaviourReference>(ref entranceTeleportReference, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2821486977u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetThingOutsideClientRpc(setOutside, entranceTeleportReference);
				}
			}
		}

		[ClientRpc]
		public void SetThingOutsideClientRpc(bool setOutside, NetworkBehaviourReference entranceTeleportReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0098: 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_00b2: 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_0105: 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: Expected O, but got Unknown
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(287792244u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref setOutside, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkBehaviourReference>(ref entranceTeleportReference, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 287792244u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					isOutside = setOutside;
					lastUsedEntranceTeleport = (EntranceTeleport)NetworkBehaviourReference.op_Implicit(entranceTeleportReference);
					OnUseEntranceTeleport.Invoke(setOutside);
				}
			}
		}

		private Vector3 FindClosestValidPoint()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return agent.pathEndPosition;
		}

		private Vector3 WarpForwardUntilOnNavMesh(Vector3 originalDestination)
		{
			//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_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_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_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_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_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_0090: Unknown result type (might be due to invalid IL or missing references)
			Vector3 forward = ((Component)agent).transform.forward;
			float num = 0.2f;
			float num2 = 50f;
			float num3 = 1f;
			NavMeshHit val2 = default(NavMeshHit);
			for (int i = 0; (float)i < num2; i++)
			{
				Vector3 val = originalDestination + forward * num * (float)(i + 1);
				if (NavMesh.SamplePosition(val, ref val2, num3, -1))
				{
					return ((NavMeshHit)(ref val2)).position;
				}
			}
			MysteryDice.CustomLogger.LogWarning((object)"Unable to find valid point on NavMesh by warping forward.");
			return Vector3.zero;
		}

		public void AdjustSpeedBasedOnDistance(float multiplierBoost)
		{
			float num = 0f;
			float num2 = 40f;
			float num3 = 0f;
			float num4 = 10f;
			float num5 = Mathf.Clamp(agent.remainingDistance, num, num2);
			float num6 = (num5 - num) / (num2 - num);
			agent.speed = Mathf.Lerp(num3, num4, num6) * multiplierBoost;
		}

		public void StopNavigation()
		{
			if ((Object)(object)agent != (Object)null)
			{
				agent.isStopped = true;
				agent.ResetPath();
			}
		}

		public void WarpToLocation(Vector3 location)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			agent.Warp(location);
		}

		public bool CurrentPathIsValid()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			if ((int)agent.path.status == 1 || (int)agent.path.status == 2)
			{
				return false;
			}
			return true;
		}

		public void StartSearchRoutine(float radius)
		{
			if (((Behaviour)agent).enabled)
			{
				_searchRadius = radius;
				StopSearchRoutine();
				_searchRoutine = ((MonoBehaviour)this).StartCoroutine(SearchAlgorithm(radius));
			}
		}

		public void StopSearchRoutine()
		{
			if (_searchRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_searchRoutine);
			}
			StopAgent();
			_searchRoutine = null;
		}

		private IEnumerator SearchAlgorithm(float radius)
		{
			yield return (object)new WaitForSeconds(Random.Range(0f, 3f));
			_positionsToSearch.Clear();
			yield return ((MonoBehaviour)this).StartCoroutine(GetSetOfAcceptableNodesForRoaming(radius));
			while (true)
			{
				Vector3 positionToTravel = _positionsToSearch.FirstOrDefault();
				if (_positionsToSearch.Count == 0 || positionToTravel == Vector3.zero)
				{
					break;
				}
				_positionsToSearch.RemoveAt(0);
				yield return ((MonoBehaviour)this).StartCoroutine(ClearProximityNodes(_positionsToSearch, positionToTravel, _nodeRemovalPrecision));
				bool reachedDestination = false;
				while (!reachedDestination)
				{
					GoToDestination(positionToTravel);
					yield return (object)new WaitForSeconds(0.5f);
					if (!((Behaviour)agent).enabled || Vector3.Distance(((Component)this).transform.position, positionToTravel) <= 3f + agent.stoppingDistance)
					{
						reachedDestination = true;
					}
				}
			}
			StartSearchRoutine(radius);
		}

		private IEnumerator GetSetOfAcceptableNodesForRoaming(float radius)
		{
			_roamingPointsVectorList.Clear();
			if (isOutside)
			{
				_roamingPointsVectorList.AddRange(RoundManager.Instance.outsideAINodes.Select((GameObject x) => (x.transform.position, x.transform.position)));
			}
			else
			{
				_roamingPointsVectorList.AddRange(RoundManager.Instance.insideAINodes.Select((GameObject x) => (x.transform.position, x.transform.position)));
			}
			if (_roamingPointsVectorList.Count == 0)
			{
				for (int i = 0; i < 20; i++)
				{
					Vector3 randomPosition = RoundManager.Instance.GetRandomNavMeshPositionInRadius(((Component)this).transform.position, radius, default(NavMeshHit));
					_roamingPointsVectorList.Add((randomPosition, randomPosition));
				}
			}
			CheckPaths(_roamingPointsVectorList, CullRoamingNodes);
			yield return (object)new WaitUntil((Func<bool>)(() => _positionsToSearch.Count > 0));
		}

		private void CullRoamingNodes(List<(Vector3 nodePosition, float distanceToNode)> NodeDistanceTuple)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < NodeDistanceTuple.Count; i++)
			{
				if (!(NodeDistanceTuple[i].distanceToNode < 0f) && !(NodeDistanceTuple[i].distanceToNode > _searchRadius))
				{
					_positionsToSearch.Add(NodeDistanceTuple[i].nodePosition);
				}
			}
			_positionsToSearch.Shuffle();
		}

		private IEnumerator ClearProximityNodes(List<Vector3> positionsToSearch, Vector3 positionToTravel, float radius)
		{
			//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)
			int count = positionsToSearch.Count;
			if (count == 0)
			{
				yield break;
			}
			for (int i = count - 1; i >= 0; i--)
			{
				if (Vector3.Distance(positionsToSearch[i], positionToTravel) <= radius)
				{
					positionsToSearch.RemoveAt(i);
				}
				yield return null;
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2821486977u, new RpcReceiveHandler(__rpc_handler_2821486977), "SetThingOutsideServerRpc");
			((NetworkBehaviour)this).__registerRpc(287792244u, new RpcReceiveHandler(__rpc_handler_287792244), "SetThingOutsideClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2821486977(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_005f: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool setOutside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref setOutside, default(ForPrimitives));
				NetworkBehaviourReference entranceTeleportReference = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref entranceTeleportReference, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SmartAgentNavigator)(object)target).SetThingOutsideServerRpc(setOutside, entranceTeleportReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_287792244(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_005f: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool setOutside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref setOutside, default(ForPrimitives));
				NetworkBehaviourReference entranceTeleportReference = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref entranceTeleportReference, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SmartAgentNavigator)(object)target).SetThingOutsideClientRpc(setOutside, entranceTeleportReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "SmartAgentNavigator";
		}
	}
	public class FindPathThroughTeleportsOperation : PathfindingOperation
	{
		private EntranceTeleport[] entranceTeleports;

		private PooledFindPathJob[] FindDestinationJobs;

		private PooledFindPathJob? FindDirectPathToDestinationJob;

		private PooledFindPathJob[] FindEntrancePointJobs;

		public FindPathThroughTeleportsOperation(IEnumerable<EntranceTeleport> entrancePoints, Vector3 startPos, Vector3 endPos, NavMeshAgent agent)
		{
			//IL_001e: 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_0035: 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_00d6: 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_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_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_0117: 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_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)
			FindDirectPathToDestinationJob = JobPools.GetFindPathJob();
			((FindPathJob)(ref FindDirectPathToDestinationJob.Job)).Initialize(startPos, endPos, agent);
			JobHandle val = IJobExtensions.ScheduleByRef<FindPathJob>(ref FindDirectPathToDestinationJob.Job, default(JobHandle));
			entranceTeleports = entrancePoints.ToArray();
			FindEntrancePointJobs = (PooledFindPathJob[])(object)new PooledFindPathJob[entranceTeleports.Length];
			FindDestinationJobs = (PooledFindPathJob[])(object)new PooledFindPathJob[entranceTeleports.Length];
			for (int i = 0; i < entranceTeleports.Length; i++)
			{
				EntranceTeleport val2 = entranceTeleports[i];
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.exitScript.entrancePoint == (Object)null) && !((Object)(object)val2.entrancePoint == (Object)null))
				{
					PooledFindPathJob findPathJob = JobPools.GetFindPathJob();
					PooledFindPathJob findPathJob2 = JobPools.GetFindPathJob();
					((FindPathJob)(ref findPathJob.Job)).Initialize(startPos, val2.entrancePoint.position, agent);
					((FindPathJob)(ref findPathJob2.Job)).Initialize(val2.exitScript.entrancePoint.position, endPos, agent);
					val = IJobExtensions.ScheduleByRef<FindPathJob>(ref findPathJob.Job, val);
					val = IJobExtensions.ScheduleByRef<FindPathJob>(ref findPathJob2.Job, val);
					FindEntrancePointJobs[i] = findPathJob;
					FindDestinationJobs[i] = findPathJob2;
				}
			}
		}

		public override void Dispose()
		{
			if (FindDirectPathToDestinationJob != null)
			{
				JobPools.ReleaseFindPathJob(FindDirectPathToDestinationJob);
				FindDirectPathToDestinationJob = null;
			}
			PooledFindPathJob[] findEntrancePointJobs = FindEntrancePointJobs;
			foreach (PooledFindPathJob val in findEntrancePointJobs)
			{
				if (val != null)
				{
					JobPools.ReleaseFindPathJob(val);
				}
			}
			PooledFindPathJob[] findDestinationJobs = FindDestinationJobs;
			foreach (PooledFindPathJob val2 in findDestinationJobs)
			{
				if (val2 != null)
				{
					JobPools.ReleaseFindPathJob(val2);
				}
			}
			entranceTeleports = Array.Empty<EntranceTeleport>();
			FindEntrancePointJobs = Array.Empty<PooledFindPathJob>();
			FindDestinationJobs = Array.Empty<PooledFindPathJob>();
		}

		public bool TryGetShortestPath(out bool foundPath, out float totalDistance, out EntranceTeleport? entranceTeleport)
		{
			//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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//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_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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between Unknown and I4
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Invalid comparison between Unknown and I4
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Invalid comparison between Unknown and I4
			totalDistance = -1f;
			float num = float.MaxValue;
			foundPath = false;
			entranceTeleport = null;
			if (FindDirectPathToDestinationJob == null)
			{
				return false;
			}
			PathQueryStatus result = PathQueryStatusExtensions.GetResult(((FindPathJob)(ref FindDirectPathToDestinationJob.Job)).GetStatus());
			if ((int)result == 536870912)
			{
				return false;
			}
			if ((int)result == 1073741824)
			{
				num = ((FindPathJob)(ref FindDirectPathToDestinationJob.Job)).GetPathLength();
				foundPath = true;
			}
			for (int i = 0; i < FindEntrancePointJobs.Length; i++)
			{
				if ((Object)(object)entranceTeleports[i] == (Object)null || FindEntrancePointJobs[i] == null || FindDestinationJobs[i] == null)
				{
					continue;
				}
				PathQueryStatus result2 = PathQueryStatusExtensions.GetResult(((FindPathJob)(ref FindEntrancePointJobs[i].Job)).GetStatus());
				PathQueryStatus result3 = PathQueryStatusExtensions.GetResult(((FindPathJob)(ref FindDestinationJobs[i].Job)).GetStatus());
				if ((int)result2 == 536870912)
				{
					return false;
				}
				if ((int)result3 == 536870912)
				{
					return false;
				}
				if ((int)result2 != int.MinValue && (int)result3 != int.MinValue)
				{
					float pathLength = ((FindPathJob)(ref FindEntrancePointJobs[i].Job)).GetPathLength();
					float pathLength2 = ((FindPathJob)(ref FindDestinationJobs[i].Job)).GetPathLength();
					float num2 = pathLength2 + pathLength;
					if (num2 < num)
					{
						entranceTeleport = entranceTeleports[i];
						num = num2;
						foundPath = true;
					}
				}
			}
			Dispose();
			totalDistance = num;
			return true;
		}

		public override bool HasDisposed()
		{
			return FindDirectPathToDestinationJob == null;
		}
	}
	public abstract class PathfindingOperation : IDisposable
	{
		public abstract void Dispose();

		public abstract bool HasDisposed();

		~PathfindingOperation()
		{
			Dispose();
		}
	}
	public class PlayerTracker : MonoBehaviour
	{
		public PlayerControllerB trackedPlayer;

		public ulong steamID;

		private Vector3 offset;

		public void init(PlayerControllerB player, Vector3 offset, ulong steamIDs)
		{
			//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)
			trackedPlayer = player;
			this.offset = offset;
			steamID = steamIDs;
		}

		public void Update()
		{
			//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)
			if ((Object)(object)trackedPlayer != (Object)null)
			{
				((Component)this).transform.position = ((Component)trackedPlayer).transform.position + offset;
			}
			if (!Misc.IsPlayerReal(trackedPlayer))
			{
				Transform val = ((Component)trackedPlayer).transform.Find("CustomPlayerScanNode");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}
	}
	public class MyScanNodeInfo : MonoBehaviour
	{
		private GameObject scanNodeInfo;

		public void Init(GameObject sn, PlayerControllerB player = null, MaskedPlayerEnemy masked = null)
		{
			scanNodeInfo = sn;
		}

		public GameObject getScanNode()
		{
			return scanNodeInfo;
		}
	}
	public class MimicTracker : MonoBehaviour
	{
		public MaskedPlayerEnemy trackedMasked;

		private Vector3 offset;

		public void init(MaskedPlayerEnemy mask, Vector3 offset)
		{
			//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)
			trackedMasked = mask;
			this.offset = offset;
		}

		public void Update()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)trackedMasked))
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			((Component)this).transform.position = ((Component)trackedMasked).transform.position + offset;
			if (((EnemyAI)trackedMasked).isEnemyDead)
			{
				Transform val = ((Component)trackedMasked).transform.Find("CustomPlayerScanNode");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
	public class RainbowScanNode : MonoBehaviour
	{
		private ForceScanColorOnItem scanNodeForcer;

		private void Awake()
		{
			scanNodeForcer = ((Component)this).GetComponentInChildren<ForceScanColorOnItem>();
		}

		public void Update()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			float num = Mathf.Repeat(Time.time * 0.2f, 1f);
			Color borderColor = Color.HSVToRGB(num, 1f, 1f);
			scanNodeForcer.borderColor = borderColor;
			float num2 = Mathf.Repeat(num + 0.5f, 1f);
			scanNodeForcer.textColor = Color.HSVToRGB(num2, 1f, 1f);
		}
	}
	[RequireComponent(typeof(RectTransform))]
	public class SpiderPathUI : MonoBehaviour
	{
		[Header("Canvas")]
		public Canvas rootCanvas;

		[Header("Versions")]
		public GameObject cuteOverlay;

		public GameObject SpiderOverlay;

		[Header("Timing")]
		public Vector2 roamDuration = new Vector2(1.5f, 3f);

		public float exitDuration = 1.25f;

		public Vector2 dwellOffscreen = new Vector2(0.4f, 120f);

		[Header("Curviness")]
		[Range(0f, 1f)]
		public float controlScatter = 0.55f;

		public int bezierSamplesPerSecond = 60;

		[Header("Bounds")]
		public bool autoMarginFromSize = true;

		public float margin = 50f;

		private RectTransform rt;

		private RectTransform canvasRT;

		private Vector2 boundsMin;

		private Vector2 boundsMax;

		private Vector2 p0;

		private Vector2 p1;

		private Vector2 p2;

		private Vector2 p3;

		private float t;

		private float segDuration;

		private bool exiting;

		private float offscreenTimer;

		private bool lastState;

		private void Awake()
		{
			rt = ((Component)this).GetComponent<RectTransform>();
			if (!Object.op_Implicit((Object)(object)rootCanvas))
			{
				rootCanvas = ((Component)this).GetComponentInParent<Canvas>();
			}
			canvasRT = (Object.op_Implicit((Object)(object)rootCanvas) ? ((Component)rootCanvas).GetComponent<RectTransform>() : null);
			if (!Object.op_Implicit((Object)(object)canvasRT))
			{
				((Behaviour)this).enabled = false;
				return;
			}
			lastState = CurrentSpiderSafe();
			if (Object.op_Implicit((Object)(object)cuteOverlay))
			{
				cuteOverlay.SetActive(lastState);
			}
			SpiderOverlay.SetActive(!lastState);
			RebuildBounds();
			BeginRoam();
		}

		private void OnRectTransformDimensionsChange()
		{
			if (Object.op_Implicit((Object)(object)canvasRT))
			{
				RebuildBounds();
			}
		}

		private void RebuildBounds()
		{
			//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_000f: 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)
			//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_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_0055: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = canvasRT.rect;
			Vector2 val = ((Rect)(ref rect)).size * 0.5f;
			float num = (autoMarginFromSize ? AutoMargin(rt) : margin);
			boundsMin = -val - new Vector2(num, num);
			boundsMax = val + new Vector2(num, num);
		}

		private float AutoMargin(RectTransform r)
		{
			//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_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_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)
			Rect rect = r.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			return 0.5f * Mathf.Max(size.x, size.y);
		}

		private static bool CurrentSpiderSafe()
		{
			IngamePlayerSettings instance = IngamePlayerSettings.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			bool? flag = instance.unsavedSettings?.spiderSafeMode;
			bool? flag2 = instance.settings?.spiderSafeMode;
			return flag ?? (flag2 == true);
		}

		private void Update()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.inShipPhase || StartOfRound.Instance.shipIsLeaving)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			bool flag = CurrentSpiderSafe();
			if (flag != lastState)
			{
				lastState = flag;
				cuteOverlay.SetActive(flag);
				SpiderOverlay.SetActive(!flag);
			}
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			if (offscreenTimer > 0f)
			{
				offscreenTimer -= unscaledDeltaTime;
				if (offscreenTimer <= 0f)
				{
					BeginRoam();
				}
			}
			else
			{
				if (segDuration <= 0f)
				{
					return;
				}
				t += unscaledDeltaTime / segDuration;
				if (t >= 1f)
				{
					SetOnCurve(1f);
					if (!exiting)
					{
						BeginExit();
					}
					else
					{
						BeginOffscreenDwell();
					}
				}
				else
				{
					SetOnCurve(t);
				}
			}
		}

		private void BeginRoam()
		{
			//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_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_0045: 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_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)
			exiting = false;
			segDuration = Random.Range(roamDuration.x, roamDuration.y);
			t = 0f;
			Vector2 currentLocal = GetCurrentLocal();
			p0 = currentLocal;
			p3 = RandomPointIn(boundsMin, boundsMax);
			MakeControls(p0, p3, out p1, out p2, onExit: false);
		}

		private void BeginExit()
		{
			//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_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_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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			exiting = true;
			segDuration = exitDuration;
			t = 0f;
			Vector2 currentLocal = GetCurrentLocal();
			p0 = currentLocal;
			p3 = RandomOffscreenPoint(boundsMin, boundsMax);
			MakeControls(p0, p3, out p1, out p2, onExit: true);
		}

		private void BeginOffscreenDwell()
		{
			offscreenTimer = Random.Range(dwellOffscreen.x, dwellOffscreen.y);
		}

		private void SetOnCurve(float tt)
		{
			//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_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_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_0027: 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_0033: 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_0045: 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)
			Vector2 anchoredPosition = Bezier(p0, p1, p2, p3, tt);
			Vector2 val = BezierTangent(p0, p1, p2, p3, tt);
			rt.anchoredPosition = anchoredPosition;
			if (((Vector2)(ref val)).sqrMagnitude > 1E-06f)
			{
				((Transform)rt).up = Vector2.op_Implicit(((Vector2)(ref val)).normalized);
			}
		}

		private Vector2 GetCurrentLocal()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return rt.anchoredPosition;
		}

		private static Vector2 Bezier(Vector2 a, Vector2 b, Vector2 c, Vector2 d, float t)
		{
			//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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003f: 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_0057: 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)
			float num = 1f - t;
			return num * num * num * a + 3f * num * num * t * b + 3f * num * t * t * c + t * t * t * d;
		}

		private static Vector2 BezierTangent(Vector2 a, Vector2 b, Vector2 c, Vector2 d, float t)
		{
			//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_0029: 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_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)
			//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_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_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)
			float num = 1f - t;
			return 3f * num * num * (b - a) + 6f * num * t * (c - b) + 3f * t * t * (d - c);
		}

		private void MakeControls(Vector2 start, Vector2 end, out Vector2 c1, out Vector2 c2, bool onExit)
		{
			//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_0003: 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_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_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_0029: 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_0036: 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_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_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_0087: 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_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_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_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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_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_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_00f4: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_012b: 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_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)
			Vector2 val = (start + end) * 0.5f;
			Vector2 val2 = end - start;
			float num = ((Vector2)(ref val2)).magnitude + 0.001f;
			Vector2 val3 = new Vector2(0f - val2.y, val2.x) / num;
			float num2 = controlScatter;
			Rect rect = canvasRT.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			float num3 = num2 * Mathf.Min(num, ((Vector2)(ref size)).magnitude);
			float num4 = Random.Range(0f - num3, num3);
			float num5 = Random.Range(0f - num3, num3);
			c1 = Vector2.Lerp(start, val, 0.33f) + val3 * num4;
			c2 = Vector2.Lerp(val, end, 0.66f) + val3 * num5;
			if (onExit)
			{
				c1 = Vector2.Lerp(c1, end, 0.15f);
				c2 = Vector2.Lerp(c2, end, 0.25f);
			}
			if (!onExit)
			{
				c1 = ClampTo(boundsMin, boundsMax, c1);
				c2 = ClampTo(boundsMin, boundsMax, c2);
			}
		}

		private Vector2 RandomPointIn(Vector2 min, Vector2 max)
		{
			//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_0012: 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_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)
			return new Vector2(Random.Range(min.x, max.x), Random.Range(min.y, max.y));
		}

		private Vector2 RandomOffscreenPoint(Vector2 min, Vector2 max)
		{
			//IL_0001: 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_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_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_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_0087: 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)
			float x = min.x;
			float x2 = max.x;
			float y = min.y;
			float y2 = max.y;
			return (Vector2)(Random.Range(0, 4) switch
			{
				0 => new Vector2(x, Random.Range(y, y2)), 
				1 => new Vector2(x2, Random.Range(y, y2)), 
				2 => new Vector2(Random.Range(x, x2), y), 
				_ => new Vector2(Random.Range(x, x2), y2), 
			});
		}

		private static Vector2 ClampTo(Vector2 min, Vector2 max, Vector2 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)
			//IL_000d: 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_0024: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(Mathf.Clamp(p.x, min.x, max.x), Mathf.Clamp(p.y, min.y, max.y));
		}
	}
}
namespace MysteryDice.Gal
{
	public class Charger : NetworkBehaviour
	{
		public InteractTrigger ActivateOrDeactivateTrigger = null;

		public Transform ChargeTransform = null;

		[NonSerialized]
		public GalAI GalAI = null;

		[NonSerialized]
		public static List<Charger> Instances = new List<Charger>();

		private static readonly int ActivatedAnimation = Animator.StringToHash("isActivated");

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			Instances.Add(this);
		}

		public IEnumerator ActivateGalAfterLand()
		{
			if (!((NetworkBehaviour)this).IsServer)
			{
				yield break;
			}
			while (true)
			{
				yield return (object)new WaitUntil((Func<bool>)(() => TimeOfDay.Instance.normalizedTimeOfDay <= 0.12f && StartOfRound.Instance.shipHasLanded && !GalAI.Animator.GetBool(ActivatedAnimation) && !StartOfRound.Instance.shipIsLeaving && !StartOfRound.Instance.inShipPhase && RoundManager.Instance.currentLevel.levelID != 3));
				MysteryDice.ExtendedLogging("Activating  Gal" + TimeOfDay.Instance.normalizedTimeOfDay, (LogLevel)16);
				if (!GalAI.Animator.GetBool(ActivatedAnimation))
				{
					int playerIndex = Array.IndexOf(value: (from p in StartOfRound.Instance.allPlayerScripts
						where p.isPlayerControlled && !p.isPlayerDead
						orderby Vector3.Distance(((Component)this).transform.position, ((Component)p).transform.position)
						select p).First(), array: StartOfRound.Instance.allPlayerScripts);
					if (!((NetworkBehaviour)this).NetworkObject.IsSpawned)
					{
						break;
					}
					ActivateGirlServerRpc(playerIndex);
				}
			}
		}

		public void OnActivateGal(PlayerControllerB playerInteracting)
		{
			MysteryDice.ExtendedLogging("Activate Ran", (LogLevel)16);
			if (((NetworkBehaviour)this).NetworkObject.IsSpawned && !((Object)(object)playerInteracting == (Object)null) && playerInteracting.IsLocalPlayer() && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded && !StartOfRound.Instance.shipIsLeaving && (RoundManager.Instance.currentLevel.levelID != 3 || MysteryDice.NavMeshInCompanyPresent) && (!MysteryDice.CompanyGal.Value || (!(StartOfRound.Instance.currentLevel.PlanetName == "71 Gordion") && !(StartOfRound.Instance.currentLevel.PlanetName == "98 Galetry") && !(StartOfRound.Instance.currentLevel.sceneName == "Oxyde"))))
			{
				if (!GalAI.Animator.GetBool(ActivatedAnimation))
				{
					ActivateGirlServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerInteracting));
				}
				else if (!MysteryDice.ConfigOnlyOwnerDisablesGal.Value || !((Object)(object)playerInteracting != (Object)(object)GalAI.ownerPlayer))
				{
					ActivateGirlServerRpc(-1);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ActivateGirlServerRpc(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3069452851u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, index);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3069452851u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GalAI.Animator.SetBool(ActivatedAnimation, index != -1);
					ActivateGirlClientRpc(index);
				}
			}
		}

		[ClientRpc]
		private void ActivateGirlClientRpc(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2410881276u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, index);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2410881276u, val2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (index != -1)
				{
					GalAI.ActivateGal(StartOfRound.Instance.allPlayerScripts[index]);
				}
				else
				{
					GalAI.DeactivateGal();
				}
			}
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			Instances.Remove(this);
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3069452851u, new RpcReceiveHandler(__rpc_handler_3069452851), "ActivateGirlServerRpc");
			((NetworkBehaviour)this).__registerRpc(2410881276u, new RpcReceiveHandler(__rpc_handler_2410881276), "ActivateGirlClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_3069452851(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Charger)(object)target).ActivateGirlServerRpc(index);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2410881276(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Charger)(object)target).ActivateGirlClientRpc(index);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "Charger";
		}
	}
	public class DiceCharger : Charger
	{
		public override void OnNetworkSpawn()
		{
			//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)
			base.OnNetworkSpawn();
			if (((NetworkBehaviour)this).IsServer)
			{
				GalAI = Object.Instantiate<GameObject>(MysteryDice.DiceGal, ChargeTransform.position, ChargeTransform.rotation).GetComponent<GalAI>();
				NetworkObject component = ((Component)GalAI).GetComponent<NetworkObject>();
				GalAI.GalCharger = this;
				component.Spawn(false);
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "DiceCharger";
		}
	}
	public class DiceGalAI : GalAI
	{
		public enum State
		{
			Inactive,
			Active,
			FollowingPlayer,
			Dancing,
			SpecialAction,
			Idle
		}

		[Header("Interact Triggers")]
		[SerializeField]
		private InteractTrigger _collisionTrigger = null;

		[SerializeField]
		private InteractTrigger _onTheHouseInteractTrigger = null;

		[SerializeField]
		private InteractTrigger _feelingLuckyInteractTrigger = null;

		[SerializeField]
		private InteractTrigger _devilishDealInteractTrigger = null;

		[Header("Sounds")]
		[SerializeField]
		private AudioSource _specialSource = null;

		[SerializeField]
		private AudioSource _flyingSource = null;

		[SerializeField]
		private AudioClip _onTheHouseSound = null;

		[SerializeField]
		private AudioClip _feelingLuckySound = null;

		[SerializeField]
		private AudioClip _devilishDealSound = null;

		[SerializeField]
		private AudioClip _collisionSwitchSound = null;

		[SerializeField]
		private AudioClip[] _startOrEndFlyingAudioClips = Array.Empty<AudioClip>();

		private bool flying = false;

		private Coroutine? _assRoutine = null;

		private Coroutine? _plateRoutine = null;

		private Coroutine? _feelingLuckyRoutine = null;

		private Coroutine? _idleResetCoroutine = null;

		private State galState = State.Inactive;

		private static readonly int DanceAnimation = Animator.StringToHash("isDancing");

		private static readonly int ActivatedAnimation = Animator.StringToHash("isActivated");

		private static readonly int RunSpeedFloat = Animator.StringToHash("RunSpeedFloat");

		private static readonly int FlyingAnimation = Animator.StringToHash("isFlying");

		private static readonly int EffectChoice = Animator.StringToHash("effectChoice");

		private static readonly int spin = Animator.StringToHash("spin");

		private static readonly int deal = Animator.StringToHash("deal");

		private static readonly int serve = Animator.StringToHash("serve");

		private static readonly int RandomIdle = Animator.StringToHash("RandomIdle");

		public static List<IEffect> GalEffects = new List<IEffect>();

		private float _assCooldownEndTime = 0f;

		private float _plateCooldownEndTime = 0f;

		private float _headCooldownEndTime = 0f;

		public bool colliderChecked = false;

		private void StartUpDelay()
		{
			List<DiceCharger> list = new List<DiceCharger>();
			foreach (Charger instance in Charger.Instances)
			{
				if (instance is DiceCharger item)
				{
					list.Add(item);
				}
			}
			if (list.Count <= 0)
			{
				if (((NetworkBehaviour)this).IsServer)
				{
					((NetworkBehaviour)this).NetworkObject.Despawn(true);
				}
				MysteryDice.CustomLogger.LogError((object)"DiceCharger not found in scene. TerminalGalAI will not be functional.");
				return;
			}
			DiceCharger diceCharger = list.OrderBy((DiceCharger x) => Vector3.Distance(((Component)this).transform.position, ((Component)x).transform.position)).First();
			diceCharger.GalAI = this;
			GalCharger = diceCharger;
			if (MysteryDice.ConfigGalAutomatic.Value)
			{
				((MonoBehaviour)this).StartCoroutine(GalCharger.ActivateGalAfterLand());
			}
			((UnityEvent<PlayerControllerB>)(object)GalCharger.ActivateOrDeactivateTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)GalCharger.OnActivateGal);
			((UnityEvent<PlayerControllerB>)(object)_collisionTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)OnChestInteract);
			((UnityEvent<PlayerControllerB>)(object)_onTheHouseInteractTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)OnPlateTrigger);
			((UnityEvent<PlayerControllerB>)(object)_devilishDealInteractTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)OnAssTrigger);
			((UnityEvent<PlayerControllerB>)(object)_feelingLuckyInteractTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)OnHeadTrigger);
		}

		private void OnChestInteract(PlayerControllerB playerInteracting)
		{
			if (playerInteracting.IsLocalPlayer() && !((Object)(object)playerInteracting != (Object)(object)ownerPlayer))
			{
				OnChestInteractServerRpc(PlayerControllerReference.op_Implicit(playerInteracting));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void OnChestInteractServerRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(264271390u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 264271390u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				OnChestInteractClientRpc(playerControllerReference);
			}
		}

		[ClientRpc]
		private void OnChestInteractClientRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2038901481u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2038901481u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				GalVoice.PlayOneShot(_collisionSwitchSound);
				EnablePhysics(!physicsEnabled);
			}
		}

		private void OnAssTrigger(PlayerControllerB playerInteracting)
		{
			if (_assRoutine == null && playerInteracting.IsLocalPlayer() && !((Object)(object)playerInteracting != (Object)(object)ownerPlayer))
			{
				OnAssInteractServerRpc(PlayerControllerReference.op_Implicit(playerInteracting));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void OnAssInteractServerRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2856052250u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2856052250u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!(Time.time < _assCooldownEndTime))
				{
					_assCooldownEndTime = Time.time + (float)MysteryDice.DevilDealCooldown.Value;
					HandleStateAnimationSpeedChanges(State.SpecialAction);
					OnAssInteractClientRpc(playerControllerReference);
					NetworkAnimator.SetTrigger(deal, true);
				}
			}
		}

		[ClientRpc]
		private void OnAssInteractClientRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2874478722u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2874478722u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				_assRoutine = ((MonoBehaviour)this).StartCoroutine(DoDevilishDeal(PlayerControllerReference.op_Implicit(playerControllerReference)));
			}
		}

		private IEnumerator DoDevilishDeal(PlayerControllerB playerDoingDeal)
		{
			yield return null;
			if (((NetworkBehaviour)this).IsServer && galState == State.SpecialAction)
			{
				switch (galRandom.Next(0, 4))
				{
				case 0:
					ReturnToShipTogether.TeleportToShipTogether(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerDoingDeal));
					break;
				case 1:
					Networker.Instance.ZombieToShipServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerDoingDeal));
					break;
				default:
					Networker.Instance.TeleportToShipServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerDoingDeal));
					break;
				}
				IEffect RandomEffect = getRandomGalEffectByType(EffectType.Awful);
				RandomEffect.Use();
				Networker.Instance.LogEffectsToOwnerServerRPC(playerDoingDeal.playerUsername, RandomEffect.Name, -666);
				HandleStateAnimationSpeedChangesServerRpc(2);
			}
			_assRoutine = null;
		}

		public IEffect getRandomGalEffectByType(EffectType type)
		{
			List<IEffect> list = GalEffects.Where((IEffect x) => x.Outcome == type).ToList();
			if (list.Count == 0)
			{
				return GalEffects[galRandom.Next(0, GalEffects.Count)];
			}
			return list[galRandom.Next(list.Count)];
		}

		private void OnPlateTrigger(PlayerControllerB playerInteracting)
		{
			if (_plateRoutine == null && playerInteracting.IsLocalPlayer() && !((Object)(object)playerInteracting != (Object)(object)ownerPlayer))
			{
				OnPlateInteractServerRpc(PlayerControllerReference.op_Implicit(playerInteracting));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void OnPlateInteractServerRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1519471416u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1519471416u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!(Time.time < _plateCooldownEndTime))
				{
					_plateCooldownEndTime = Time.time + (float)MysteryDice.OnTheHouseCooldown.Value;
					HandleStateAnimationSpeedChanges(State.SpecialAction);
					OnPlateInteractClientRpc(playerControllerReference);
					NetworkAnimator.SetTrigger(serve, true);
				}
			}
		}

		[ClientRpc]
		private void OnPlateInteractClientRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1609878064u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1609878064u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				_plateRoutine = ((MonoBehaviour)this).StartCoroutine(OnTheHouseDeal(PlayerControllerReference.op_Implicit(playerControllerReference)));
			}
		}

		private IEnumerator OnTheHouseDeal(PlayerControllerB playerDoingDeal)
		{
			yield return null;
			if (((NetworkBehaviour)this).IsServer && galState == State.SpecialAction)
			{
				Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, ownerPlayer), 1, MysteryDice.RegisteredDice[galRandom.Next(0, MysteryDice.RegisteredDice.Count)].itemName, usePos: true, ((Component)_onTheHouseInteractTrigger).transform.position);
				HandleStateAnimationSpeedChangesServerRpc(2);
			}
			_plateRoutine = null;
		}

		private void OnHeadTrigger(PlayerControllerB playerInteracting)
		{
			if (_feelingLuckyRoutine == null && playerInteracting.IsLocalPlayer() && !((Object)(object)playerInteracting != (Object)(object)ownerPlayer))
			{
				OnHeadInteractServerRpc(PlayerControllerReference.op_Implicit(playerInteracting));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void OnHeadInteractServerRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1852186319u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1852186319u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!(Time.time < _headCooldownEndTime))
				{
					_headCooldownEndTime = Time.time + (float)MysteryDice.ImFeelingLuckyCooldown.Value;
					HandleStateAnimationSpeedChanges(State.SpecialAction);
					OnHeadInteractClientRpc(playerControllerReference);
					NetworkAnimator.SetTrigger(spin, true);
				}
			}
		}

		[ClientRpc]
		private void OnHeadInteractClientRpc(PlayerControllerReference playerControllerReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_010c: 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_00ac: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1608084163u, val2, (RpcDelivery)0);
				bool flag = playerControllerReference != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1608084163u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				_feelingLuckyRoutine = ((MonoBehaviour)this).StartCoroutine(FeelingLuckyDeal(PlayerControllerReference.op_Implicit(playerControllerReference)));
			}
		}

		private IEnumerator FeelingLuckyDeal(PlayerControllerB playerDoingDeal)
		{
			yield return null;
			NetworkAnimator.Animator.SetFloat(EffectChoice, 0f);
			IEffect effectToUse = null;
			if (((NetworkBehaviour)this).IsServer)
			{
				effectToUse = GalEffects[galRandom.Next(0, GalEffects.Count)];
			}
			yield return (object)new WaitForSeconds(3f);
			if (!((NetworkBehaviour)this).IsServer || galState != State.SpecialAction || effectToUse == null)
			{
				_feelingLuckyRoutine = null;
				yield break;
			}
			int effectRollNumber = 0;
			switch (effectToUse.Outcome)
			{
			case EffectType.Awful:
				effectRollNumber = -666;
				NetworkAnimator.Animator.SetInteger(EffectChoice, 1);
				break;
			case EffectType.Bad:
				effectRollNumber = -100;
				NetworkAnimator.Animator.SetInteger(EffectChoice, 2);
				break;
			case EffectType.Mixed:
				effectRollNumber = 123;
				NetworkAnimator.Animator.SetInteger(EffectChoice, 3);
				break;
			case EffectType.Great:
				effectRollNumber = 777;
				NetworkAnimator.Animator.SetInteger(EffectChoice, 4);
				break;
			default:
				NetworkAnimator.Animator.SetInteger(EffectChoice, 2);
				break;
			}
			Networker.Instance.LogEffectsToOwnerServerRPC(playerDoingDeal.playerUsername, effectToUse.Name, effectRollNumber);
			effectToUse.Use();
			yield return (object)new WaitForSeconds(2f);
			NetworkAnimator.Animator.SetFloat(EffectChoice, 0f);
			if (galState == State.SpecialAction)
			{
				HandleStateAnimationSpeedChangesServerRpc(2);
			}
			_feelingLuckyRoutine = null;
		}

		public float DoCalculatePathDistance(NavMeshPath path)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0035: 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)
			float num = 0f;
			if ((int)path.status != 2 && path.corners.Length >= 1)
			{
				for (int i = 1; i < path.corners.Length; i++)
				{
					num += Vector3.Distance(path.corners[i - 1], path.corners[i]);
				}
			}
			MysteryDice.ExtendedLogging($"Path distance: {num}", (LogLevel)16);
			return num;
		}

		public override void ActivateGal(PlayerControllerB owner)
		{
			base.ActivateGal(owner);
			ResetToChargerStation(State.Active);
		}

		private void ResetToChargerStation(State state)
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				if (((Behaviour)Agent).enabled)
				{
					Agent.Warp(GalCharger.ChargeTransform.position);
				}
				((Component)this).transform.SetPositionAndRotation(GalCharger.ChargeTransform.position, Quaternion.identity);
				HandleStateAnimationSpeedChangesServerRpc((int)state);
			}
		}

		public override void DeactivateGal()
		{
			base.DeactivateGal();
			ResetToChargerStation(State.Inactive);
		}

		private void InteractTriggersUpdate()
		{
			bool flag = !inActive && (Object)(object)ownerPlayer != (Object)null && (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)ownerPlayer;
			bool interactable = galState != State.SpecialAction && flag && galState != State.Idle;
			_onTheHouseInteractTrigger.interactable = flag;
			_devilishDealInteractTrigger.interactable = interactable;
			_feelingLuckyInteractTrigger.interactable = interactable;
			_collisionTrigger.interactable = interactable;
		}

		private void StoppingDistanceUpdate()
		{
			Agent.stoppingDistance = 3f;
		}

		private void SetIdleDefaultStateForEveryone()
		{
			if ((Object)(object)GalCharger == (Object)null || (((NetworkBehaviour)this).IsServer && !doneOnce))
			{
				doneOnce = true;
				MysteryDice.CustomLogger.LogInfo((object)"Syncing for client");
				galRandom = new Random(StartOfRound.Instance.randomMapSeed + 69);
				chargeCount = 0;
				maxChargeCount = chargeCount;
				((Behaviour)Agent).enabled = false;
				StartUpDelay();
			}
		}

		public override void InActiveUpdate()
		{
			base.InActiveUpdate();
			inActive = galState == State.Inactive;
		}

		public override void Update()
		{
			base.Update();
			SetIdleDefaultStateForEveryone();
			InteractTriggersUpdate();
			if (inActive)
			{
				if (!colliderChecked)
				{
					colliderOff();
					colliderChecked = true;
				}
				return;
			}
			if (colliderChecked)
			{
				colliderFix();
				colliderChecked = false;
			}
			StoppingDistanceUpdate();
			if (galRandom.Next(500000) <= 3)
			{
				_specialSource.Stop();
				_specialSource.Play();
			}
			if (((NetworkBehaviour)this).IsHost)
			{
				HostSideUpdate();
			}
		}

		private float GetCurrentSpeedMultiplier()
		{
			return 1.3f;
		}

		[ClientRpc]
		public void playSoundFromGalClientRPC(string soundName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_0088: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2113713030u, val2, (RpcDelivery)0);
				bool flag = soundName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(soundName, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2113713030u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				MysteryDice.sounds.TryGetValue(soundName, out var value);
				if (!((Object)(object)value == (Object)null))
				{
					_specialSource.clip = value;
					_specialSource.Play();
				}
			}
		}

		private void HostSideUpdate()
		{
			//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_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)
			if (StartOfRound.Instance.shipIsLeaving || !StartOfRound.Instance.shipHasLanded || StartOfRound.Instance.inShipPhase)
			{
				GalCharger.ActivateGirlServerRpc(-1);
				return;
			}
			if (((Behaviour)Agent).enabled)
			{
				smartAgentNavigator.AdjustSpeedBasedOnDistance(GetCurrentSpeedMultiplier());
			}
			Vector3 velocity;
			if (galRandom.Next(50000) <= 3)
			{
				velocity = Agent.velocity;
				if (((Vector3)(ref velocity)).magnitude < 0.05f && galState != State.SpecialAction && galState != State.Inactive && galState != State.Dancing && _idleResetCoroutine == null)
				{
					HandleStateAnimationSpeedChanges(State.Idle);
				}
			}
			Animator animator = Animator;
			int runSpeedFloat = RunSpeedFloat;
			velocity = Agent.velocity;
			animator.SetFloat(runSpeedFloat, ((Vector3)(ref velocity)).magnitude / 2f);
			switch (galState)
			{
			case State.Inactive:
				break;
			case State.Active:
				DoActive();
				break;
			case State.FollowingPlayer:
				DoFollowingPlayer();
				break;
			case State.Dancing:
				DoDancing();
				break;
			case State.SpecialAction:
				DoSpecialActions();
				break;
			case State.Idle:
				DoRandomIdle();
				break;
			}
		}

		private void DoRandomIdle()
		{
			if (_idleResetCoroutine == null)
			{
				Animator.SetInteger(RandomIdle, galRandom.Next(1, 4));
				_idleResetCoroutine = ((MonoBehaviour)this).StartCoroutine(ResetIdle());
			}
		}

		public IEnumerator ResetIdle()
		{
			yield return null;
			AnimatorClipInfo[] clipInfo = Animator.GetCurrentAnimatorClipInfo(0);
			float waitTime = 1f;
			if (clipInfo.Length != 0)
			{
				waitTime = ((AnimatorClipInfo)(ref clipInfo[0])).clip.length;
			}
			yield return (object)new WaitForSeconds(waitTime);
			HandleStateAnimationSpeedChangesServerRpc(2);
			Animator.SetInteger(RandomIdle, 0);
			_idleResetCoroutine = null;
		}

		public override void OnEnableOrDisableAgent(bool agentEnabled)
		{
			base.OnEnableOrDisableAgent(agentEnabled);
			Animator.SetBool(FlyingAnimation, !agentEnabled);
		}

		private void DoActive()
		{
			if ((Object)(object)ownerPlayer == (Object)null)
			{
				GoToChargerAndDeactivate();
			}
			else
			{
				HandleStateAnimationSpeedChanges(State.FollowingPlayer);
			}
		}

		private void DoFollowingPlayer()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ownerPlayer == (Object)null)
			{
				GoToChargerAndDeactivate();
			}
			else if (!smartAgentNavigator.DoPathingToDestination(((Component)ownerPlayer).transform.position))
			{
				DoStaringAtOwner(ownerPlayer);
				if (!DoDancingAction())
				{
				}
			}
		}

		private void DoDancing()
		{
		}

		private void DoSpecialActions()
		{
		}

		private void PlayDevilishDealSoundAnimEvent()
		{
			GalVoice.PlayOneShot(_devilishDealSound);
		}

		private bool DoDancingAction()
		{
			if (boomboxPlaying)
			{
				HandleStateAnimationSpeedChanges(State.Dancing);
				((MonoBehaviour)this).StartCoroutine(StopDancingDelay());
				return true;
			}
			return false;
		}

		private IEnumerator StopDancingDelay()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => !boomboxPlaying || galState != State.Dancing));
			if (galState == State.Dancing)
			{
				HandleStateAnimationSpeedChanges(State.FollowingPlayer);
			}
		}

		private void StartFlyingAnimEvent()
		{
			SetFlying(Flying: true);
			((MonoBehaviour)this).StartCoroutine(FlyAnimationDelay());
		}

		private void StopFlyingAnimEvent()
		{
			SetFlying(Flying: false);
		}

		private IEnumerator FlyAnimationDelay()
		{
			smartAgentNavigator.cantMove = true;
			yield return (object)new WaitForSeconds(1.5f);
			smartAgentNavigator.cantMove = false;
		}

		private void SetFlying(bool Flying)
		{
			flying = Flying;
			if (Flying)
			{
				GalSFX.PlayOneShot(_startOrEndFlyingAudioClips[0]);
				_flyingSource.volume = MysteryDice.SoundVolume.Value;
			}
			else
			{
				GalSFX.PlayOneShot(_startOrEndFlyingAudioClips[1]);
				_flyingSource.volume = 0f;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void HandleStateAnimationSpeedChangesServerRpc(int state)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1881066776u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, state);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1881066776u, val2, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					HandleStateAnimationSpeedChanges((State)state);
				}
			}
		}

		private void HandleStateAnimationSpeedChanges(State state)
		{
			SwitchStateClientRpc((int)state);
			switch (state)
			{
			case State.Inactive:
				SetAnimatorBools(dance: false, activated: false);
				break;
			case State.Active:
				SetAnimatorBools(dance: false, activated: true);
				break;
			case State.FollowingPlayer:
				SetAnimatorBools(dance: false, activated: true);
				break;
			case State.Dancing:
				SetAnimatorBools(dance: true, activated: true);
				break;
			case State.SpecialAction:
				SetAnimatorBools(dance: false, activated: true);
				break;
			case State.Idle:
				SetAnimatorBools(dance: false, activated: true);
				break;
			}
		}

		private void SetAnimatorBools(bool dance, bool activated)
		{
			Animator.SetBool(DanceAnimation, dance);
			Animator.SetBool(ActivatedAnimation, activated);
		}

		[ClientRpc]
		private void SwitchStateClientRpc(int state)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1996209552u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, state);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1996209552u, val2, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SwitchState(state);
				}
			}
		}

		private void SwitchState(int state)
		{
			if (state != -1)
			{
				switch ((State)state)
				{
				case State.Inactive:
					HandleStateInactiveChange();
					break;
				case State.Active:
					HandleStateActiveChange();
					break;
				case State.FollowingPlayer:
					HandleStateFollowingPlayerChange();
					break;
				case State.Dancing:
					HandleStateDancingChange();
					break;
				case State.SpecialAction:
					HandleStateSpecialActionsChange();
					break;
				case State.Idle:
					HandleStateIdleChange();
					break;
				}
				galState = (State)state;
			}
		}

		private void HandleStateInactiveChange()
		{
			ownerPlayer = null;
			((Behaviour)Agent).enabled = false;
			Animator.SetBool(FlyingAnimation, false);
		}

		private void HandleStateActiveChange()
		{
			((Behaviour)Agent).enabled = true;
		}

		private void HandleStateFollowingPlayerChange()
		{
			GalVoice.PlayOneShot(GreetOwnerSound);
		}

		private void HandleStateDancingChange()
		{
		}

		private void HandleStateSpecialActionsChange()
		{
		}

		private void HandleStateIdleChange()
		{
		}

		public override void OnUseEntranceTeleport(bool setOutside)
		{
			base.OnUseEntranceTeleport(setOutside);
		}

		public override void OnEnterOrExitElevator(bool enteredElevator)
		{
			base.OnEnterOrExitElevator(enteredElevator);
		}

		public override bool Hit(int force, Vector3 hitDirection, PlayerControllerB? playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			base.Hit(force, hitDirection, playerWhoHit, playHitSFX, hitID);
			return true;
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(264271390u, new RpcReceiveHandler(__rpc_handler_264271390), "OnChestInteractServerRpc");
			((NetworkBehaviour)this).__registerRpc(2038901481u, new RpcReceiveHandler(__rpc_handler_2038901481), "OnChestInteractClientRpc");
			((NetworkBehaviour)this).__registerRpc(2856052250u, new RpcReceiveHandler(__rpc_handler_2856052250), "OnAssInteractServerRpc");
			((NetworkBehaviour)this).__registerRpc(2874478722u, new RpcReceiveHandler(__rpc_handler_2874478722), "OnAssInteractClientRpc");
			((NetworkBehaviour)this).__registerRpc(1519471416u, new RpcReceiveHandler(__rpc_handler_1519471416), "OnPlateInteractServerRpc");
			((NetworkBehaviour)this).__registerRpc(1609878064u, new RpcReceiveHandler(__rpc_handler_1609878064), "OnPlateInteractClientRpc");
			((NetworkBehaviour)this).__registerRpc(1852186319u, new RpcReceiveHandler(__rpc_handler_1852186319), "OnHeadInteractServerRpc");
			((NetworkBehaviour)this).__registerRpc(1608084163u, new RpcReceiveHandler(__rpc_handler_1608084163), "OnHeadInteractClientRpc");
			((NetworkBehaviour)this).__registerRpc(2113713030u, new RpcReceiveHandler(__rpc_handler_2113713030), "playSoundFromGalClientRPC");
			((NetworkBehaviour)this).__registerRpc(1881066776u, new RpcReceiveHandler(__rpc_handler_1881066776), "HandleStateAnimationSpeedChangesServerRpc");
			((NetworkBehaviour)this).__registerRpc(1996209552u, new RpcReceiveHandler(__rpc_handler_1996209552), "SwitchStateClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_264271390(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnChestInteractServerRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2038901481(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnChestInteractClientRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2856052250(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnAssInteractServerRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2874478722(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnAssInteractClientRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1519471416(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnPlateInteractServerRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1609878064(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnPlateInteractClientRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1852186319(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnHeadInteractServerRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1608084163(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_0058: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerControllerReference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerControllerReference, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).OnHeadInteractClientRpc(playerControllerReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2113713030(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string soundName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref soundName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).playSoundFromGalClientRPC(soundName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1881066776(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int state = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref state);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).HandleStateAnimationSpeedChangesServerRpc(state);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1996209552(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int state = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref state);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DiceGalAI)(object)target).SwitchStateClientRpc(state);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "DiceGalAI";
		}
	}
	[RequireComponent(typeof(SmartAgentNavigator))]
	public class GalAI : NetworkBehaviour, IHittable
	{
		public CRNoiseListener _GalAINoiseListener = null;

		public string GalName = "";

		public Animator Animator = null;

		public NetworkAnimator NetworkAnimator = null;

		public NavMeshAgent Agent = null;

		[NonSerialized]
		public Charger GalCharger = null;

		public Collider[] colliders = Array.Empty<Collider>();

		public AudioSource GalVoice = null;

		public AudioSource GalSFX = null;

		public AudioClip ActivateSound = null;

		public AudioClip GreetOwnerSound = null;

		public AudioClip[] IdleSounds = Array.Empty<AudioClip>();

		public AudioClip DeactivateSound = null;

		public AudioClip[] HitSounds = Array.Empty<AudioClip>();

		public AudioClip[] FootstepSounds = Array.Empty<AudioClip>();

		public float DoorOpeningSpeed = 1f;

		public Transform GalHead = null;

		public Transform GalEye = null;

		public Renderer[] renderersToHideIn = Array.Empty<Renderer>();

		public SmartAgentNavigator smartAgentNavigator = null;

		[HideInInspector]
		public static List<GalAI> Instances = new List<GalAI>();

		[HideInInspector]
		public bool boomboxPlaying = false;

		[HideInInspector]
		public float staringTimer = 0f;

		[HideInInspector]
		public const float stareThreshold = 2f;

		[HideInInspector]
		public const float STARE_DOT_THRESHOLD = 0.8f;

		[HideInInspector]
		public const float STARE_ROTATION_SPEED = 2f;

		[HideInInspector]
		public EnemyAI? targetEnemy;

		[HideInInspector]
		public PlayerControllerB? ownerPlayer;

		[HideInInspector]
		public HashSet<EnemyType> enemyTargetBlacklist = new HashSet<EnemyType>();

		[HideInInspector]
		public int chargeCount = 10;

		[HideInInspector]
		public int maxChargeCount;

		[HideInInspector]
		public bool currentlyAttacking = false;

		[HideInInspector]
		public float boomboxTimer = 0f;

		[HideInInspector]
		public bool physicsEnabled = true;

		[HideInInspector]
		public float idleNeededTimer = 10f;

		[HideInInspector]
		public float idleTimer = 0f;

		[HideInInspector]
		public Random galRandom = new Random();

		[HideInInspector]
		public bool inActive = true;

		[HideInInspector]
		public bool doneOnce = false;

		public override void OnNetworkSpawn()
		{
			//IL_006a: 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)
			((NetworkBehaviour)this).OnNetworkSpawn();
			Instances.Add(this);
			_GalAINoiseListener._onNoiseDetected.AddListener((UnityAction<NoiseParams>)DetectNoise);
			if (((NetworkBehaviour)this).IsServer)
			{
				((Component)this).transform.SetParent(((Component)GalCharger).transform, false);
				((Component)this).transform.SetPositionAndRotation(((Component)GalCharger).transform.position, ((Component)GalCharger).transform.rotation);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RefillChargesServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(186637538u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 186637538u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RefillChargesClientRpc();
				}
			}
		}

		[ClientRpc]
		public void RefillChargesClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3337567672u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3337567672u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RefillCharges();
				}
			}
		}

		public virtual void RefillCharges()
		{
			chargeCount = maxChargeCount;
		}

		public void DoGalRadarAction(bool enabled)
		{
			if (enabled)
			{
				StartOfRound.Instance.mapScreen.AddTransformAsTargetToRadar(((Component)this).transform, GalName, true);
			}
			else
			{
				StartOfRound.Instance.mapScreen.RemoveTargetFromRadar(((Component)this).transform);
			}
			StartOfRound.Instance.mapScreen.SyncOrderOfRadarBoostersInList();
		}

		public virtual void InActiveUpdate()
		{
		}

		private void BoomboxUpdate()
		{
			if (boomboxPlaying && !inActive)
			{
				boomboxTimer += Time.deltaTime;
				if (boomboxTimer >= 2f)
				{
					boomboxTimer = 0f;
					boomboxPlaying = false;
				}
			}
		}

		private void IdleUpdate()
		{
			if (!inActive)
			{
				idleTimer += Time.deltaTime;
				if (!(idleTimer <= idleNeededTimer))
				{
					idleTimer = 0f;
					idleNeededTimer = RandomExtensions.NextFloat(galRandom, 10f, 15f);
					GalSFX.PlayOneShot(IdleSounds[galRandom.Next(IdleSounds.Length)]);
					GalVoice.pitch = RandomExtensions.NextFloat(galRandom, 0.9f, 1.1f);
				}
			}
		}

		private void OwnerPlayerUpdate()
		{
			if ((Object)(object)ownerPlayer != (Object)null && ownerPlayer.isPlayerDead)
			{
				ownerPlayer = null;
			}
		}

		public virtual void Update()
		{
			if (((NetworkBehaviour)this).NetworkObject.IsSpawned)
			{
				InActiveUpdate();
				BoomboxUpdate();
				IdleUpdate();
				OwnerPlayerUpdate();
			}
		}

		public virtual void ActivateGal(PlayerControllerB owner)
		{
			ownerPlayer = owner;
			if ((Object)(object)smartAgentNavigator == (Object)null && smartAgentNavigator == null)
			{
				smartAgentNavigator = ((Component)this).GetComponent<SmartAgentNavigator>() ?? ((Component)this).GetComponentInChildren<SmartAgentNavigator>(true);
			}
			DoGalRadarAction(enabled: true);
			GalVoice.PlayOneShot(ActivateSound);
			smartAgentNavigator.SetAllValues(isOutside: true);
			smartAgentNavigator.OnEnterOrExitElevator.AddListener((UnityAction<bool>)OnEnterOrExitElevator);
			smartAgentNavigator.OnUseEntranceTeleport.AddListener((UnityAction<bool>)OnUseEntranceTeleport);
			smartAgentNavigator.OnEnableOrDisableAgent.AddListener((UnityAction<bool>)OnEnableOrDisableAgent);
		}

		public virtual void OnEnterOrExitElevator(bool enteredElevator)
		{
			MysteryDice.ExtendedLogging($"Entered Elevator: {enteredElevator}", (LogLevel)16);
		}

		public virtual void OnEnableOrDisableAgent(bool agentEnabled)
		{
			MysteryDice.ExtendedLogging($"Enabled Agent: {agentEnabled}", (LogLevel)16);
		}

		public virtual void OnUseEntranceTeleport(bool setOutside)
		{
			MysteryDice.ExtendedLogging($"Used Entrance Teleport and should be set outside: {setOutside}", (LogLevel)16);
			if (physicsEnabled)
			{
				EnablePhysics(enablePhysics: false);
			}
		}

		public virtual void DeactivateGal()
		{
			ownerPlayer = null;
			DoGalRadarAction(enabled: false);
			GalVoice.PlayOneShot(DeactivateSound);
			smartAgentNavigator.OnEnterOrExitElevator.RemoveListener((UnityAction<bool>)OnEnterOrExitElevator);
			smartAgentNavigator.OnUseEntranceTeleport.RemoveListener((UnityAction<bool>)OnUseEntranceTeleport);
			smartAgentNavigator.OnEnableOrDisableAgent.RemoveListener((UnityAction<bool>)OnEnableOrDisableAgent);
		}

		public bool GoToChargerAndDeactivate()
		{
			//IL_0012: 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_0033: 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)
			smartAgentNavigator.DoPathingToDestination(GalCharger.ChargeTransform.position);
			if (!(Vector3.Distance(((Component)this).transform.position, GalCharger.ChargeTransform.position) <= Agent.stoppingDistance) && Agent.hasPath)
			{
				Vector3 velocity = Agent.velocity;
				if (!(((Vector3)(ref velocity)).sqrMagnitude <= 0.01f))
				{
					return false;
				}
			}
			GalCharger.ActivateGirlServerRpc(-1);
			return true;
		}

		public void DoStaringAtOwner(PlayerControllerB ownerPlayer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_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_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)
			//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_00c4: 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_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_00e8: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = GalHead.position - ((Component)ownerPlayer.gameplayCamera).transform.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			float num = Vector3.Dot(((Component)ownerPlayer.gameplayCamera).transform.forward, normalized);
			if (num <= 0.8f)
			{
				staringTimer = 0f;
				return;
			}
			staringTimer += Time.deltaTime;
			if (!(staringTimer < 2f))
			{
				val = ((Component)ownerPlayer.gameplayCamera).transform.position - ((Component)this).transform.position;
				Vector3 normalized2 = ((Vector3)(ref val)).normalized;
				normalized2.y = 0f;
				Quaternion val2 = Quaternion.LookRotation(normalized2);
				((Component)this).transform.rotation = Quaternion.Slerp(((Component)this).transform.rotation, val2, Time.deltaTime * 2f);
				if (staringTimer >= 3.5f || val2 == ((Component)this).transform.rotation)
				{
					staringTimer = 0f;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EnablePhysicsServerRpc(bool enablePhysics)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1044801883u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref enablePhysics, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1044801883u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EnablePhysicsClientRpc(enablePhysics);
				}
			}
		}

		[ClientRpc]
		public void EnablePhysicsClientRpc(bool enablePhysics)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4263042770u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref enablePhysics, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 4263042770u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EnablePhysics(enablePhysics);
				}
			}
		}

		public void colliderOff()
		{
			Collider[] array = colliders;
			foreach (Collider val in array)
			{
				val.enabled = false;
			}
		}

		public void colliderFix()
		{
			Collider[] array = colliders;
			foreach (Collider val in array)
			{
				val.enabled = physicsEnabled;
			}
		}

		public void EnablePhysics(bool enablePhysics)
		{
			Collider[] array = colliders;
			foreach (Collider val in array)
			{
				val.enabled = enablePhysics;
			}
			physicsEnabled = enablePhysics;
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetEnemyTargetServerRpc(NetworkBehaviourReference networkBehaviourReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2078525420u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkBehaviourReference>(ref networkBehaviourReference, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2078525420u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetEnemyTargetClientRpc(networkBehaviourReference);
				}
			}
		}

		[ClientRpc]
		public void SetEnemyTargetClientRpc(NetworkBehaviourReference networkBehaviourReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_007d: 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_0097: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(330400137u, val2, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkBehaviourReference>(ref networkBehaviourReference, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 330400137u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					targetEnemy = (EnemyAI)NetworkBehaviourReference.op_Implicit(networkBehaviourReference);
					MysteryDice.ExtendedLogging($"{this} setting target to: {targetEnemy.enemyType.enemyName}", (LogLevel)16);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ClearEnemyTargetServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3986670846u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3986670846u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ClearEnemyTargetClientRpc();
				}
			}
		}

		[ClientRpc]
		public void ClearEnemyTargetClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4223310284u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 4223310284u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					targetEnemy = null;
				}
			}
		}

		public virtual void DetectNoise(NoiseParams noiseParams)
		{
			//IL_002b: 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)
			if (!inActive && ((NetworkBehaviour)this).IsServer && noiseParams.noiseID == 5 && !Physics.Linecast(((Component)this).transform.position, noiseParams.noisePosition, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				boomboxTimer = 0f;
				boomboxPlaying = true;
			}
		}

		public virtual bool Hit(int force, Vector3 hitDirection, PlayerControllerB? playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			if (inActive)
			{
				return false;
			}
			PlayHurtSoundServerRpc();
			return true;
		}

		[ServerRpc(RequireOwnership = false)]
		public virtual void PlayHurtSoundServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val2 = default(ServerRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3285096712u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3285096712u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayHurtSoundClientRpc();
				}
			}
		}

		[ClientRpc]
		public virtual void PlayHurtSoundClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3583090933u, val2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3583090933u, val2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GalVoice.PlayOneShot(HitSounds[galRandom.Next(HitSounds.Length)]);
				}
			}
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			Instances.Remove(this);
			if (!inActive)
			{
				DoGalRadarAction(enabled: false);
				smartAgentNavigator.OnEnterOrExitElevator.RemoveListener((UnityAction<bool>)OnEnterOrExitElevator);
				smartAgentNavigator.OnUseEntranceTeleport.RemoveListener((UnityAction<bool>)OnUseEntranceTeleport);
				smartAgentNavigator.OnEnableOrDisableAgent.RemoveListener((UnityAction<bool>)OnEnableOrDisableAgent);
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(186637538u, new RpcReceiveHandler(__rpc_handler_186637538), "RefillChargesServerRpc");
			((NetworkBehaviour)this).__registerRpc(3337567672u, new RpcReceiveHandler(__rpc_handler_3337567672), "RefillChargesClientRpc");
			((NetworkBehaviour)this).__registerRpc(1044801883u, new RpcReceiveHandler(__rpc_handler_1044801883), "EnablePhysicsServerRpc");
			((NetworkBehaviour)this).__registerRpc(4263042770u, new RpcReceiveHandler(__rpc_handler_4263042770), "EnablePhysicsClientRpc");
			((NetworkBehaviour)this).__registerRpc(2078525420u, new RpcReceiveHandler(__rpc_handler_2078525420), "SetEnemyTargetServerRpc");
			((NetworkBehaviour)this).__registerRpc(330400137u, new RpcReceiveHandler(__rpc_handler_330400137), "SetEnemyTargetClientRpc");
			((NetworkBehaviour)this).__registerRpc(3986670846u, new RpcReceiveHandler(__rpc_handler_3986670846), "ClearEnemyTargetServerRpc");
			((NetworkBehaviour)this).__registerRpc(4223310284u, new RpcReceiveHandler(__rpc_handler_4223310284), "ClearEnemyTargetClientRpc");
			((NetworkBehaviour)this).__registerRpc(3285096712u, new RpcReceiveHandler(__rpc_handler_3285096712), "PlayHurtSoundServerRpc");
			((NetworkBehaviour)this).__registerRpc(3583090933u, new RpcReceiveHandler(__rpc_handler_3583090933), "PlayHurtSoundClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_186637538(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).RefillChargesServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3337567672(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).RefillChargesClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1044801883(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool enablePhysics = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref enablePhysics, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).EnablePhysicsServerRpc(enablePhysics);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4263042770(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool enablePhysics = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref enablePhysics, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).EnablePhysicsClientRpc(enablePhysics);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2078525420(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004f: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference enemyTargetServerRpc = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref enemyTargetServerRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).SetEnemyTargetServerRpc(enemyTargetServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_330400137(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004f: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference enemyTargetClientRpc = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref enemyTargetClientRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).SetEnemyTargetClientRpc(enemyTargetClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3986670846(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).ClearEnemyTargetServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4223310284(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).ClearEnemyTargetClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3285096712(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).PlayHurtSoundServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3583090933(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GalAI)(object)target).PlayHurtSoundClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "GalAI";
		}
	}
	[RequireComponent(typeof(Collider))]
	public class CRNoiseListener : MonoBehaviour, INoiseListener
	{
		[SerializeField]
		internal UnityEvent<NoiseParams> _onNoiseDetected = new UnityEvent<NoiseParams>();

		public void DetectNoise(Vector3 noisePosition, float noiseLoudness, int timesPlayedInOneSpot, int noiseID)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_onNoiseDetected.Invoke(new NoiseParams(noisePosition, noiseLoudness, timesPlayedInOneSpot, noiseID));
		}
	}
	[Serializable]
	public class NoiseParams(Vector3 noisePosition, float noiseLoudness, int timesPlayedInOneSpot, int noiseID)
	{
		internal Vector3 noisePosition = noisePosition;

		internal float noiseLoudness = noiseLoudness;

		internal int timesPlayedInOneSpot = timesPlayedInOneSpot;

		internal int noiseID = noiseID;
	}
}
namespace MysteryDice.Extensions
{
	public static class IListExtensions
	{
		public static IList<T> Shuffle<T>(this IList<T> ts)
		{
			int count = ts.Count;
			int num = count - 1;
			for (int i = 0; i < num; i++)
			{
				int num2 = Random.Range(i, count);
				int index = i;
				int index2 = num2;
				T value = ts[num2];
				T value2 = ts[i];
				ts[index] = value;
				ts[index2] = value2;
			}
			return ts;
		}

		public static int FindIndex<T>(this IReadOnlyList<T> list, Predicate<T> match)
		{
			for (int i = 0; i < list.Count; i++)
			{
				if (match(list[i]))
				{
					return i;
				}
			}
			return -1;
		}
	}
	public static class PlayerControllerBExtensions
	{
		public static bool IsLocalPlayer(this PlayerControllerB player)
		{
			return (Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController;
		}
	}
}
namespace MysteryDice.Effects
{
	internal class AlarmCurse : IEffect
	{
		public static bool IsCursed = false;

		public static float CursedTimer = 0f;

		public static ConfigEntry<bool> fireAlarm;

		public static ConfigEntry<bool> HorribleVersion;

		public static List<AudioClip> alarmSounds = new List<AudioClip>();

		public string Name => "Alarm";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Do you hear that? ʘ\u203fʘ";

		public void Use()
		{
			PlayerControllerB val = ((IEnumerable<PlayerControllerB>)StartOfRound.Instance.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB x) => x.playerSteamId == 76561198984467725L));
			if ((Object)(object)val != (Object)null)
			{
				if (!val.isPlayerDead)
				{
					Networker.Instance.AlarmServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val));
				}
				else
				{
					Networker.Instance.AlarmServerRPC(Misc.GetRandomPlayerID());
				}
			}
			else
			{
				Networker.Instance.AlarmServerRPC(Misc.GetRandomPlayerID());
			}
		}

		public static void setAlarm()
		{
			IsCursed = true;
			CursedTimer = 3f;
		}

		public static void TimerUpdate()
		{
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			if (alarmSounds.Count == 0)
			{
				MysteryDice.sounds.TryGetValue("FireAlarm", out var value);
				if ((Object)(object)value != (Object)null)
				{
					alarmSounds.Add(value);
				}
				else
				{
					Debug.LogWarning((object)"FireAlarm Null");
				}
				MysteryDice.sounds.TryGetValue("WindowsError", out value);
				if ((Object)(object)value != (Object)null)
				{
					alarmSounds.Add(value);
				}
				else
				{
					Debug.LogWarning((object)"WindowsError Null");
				}
				MysteryDice.sounds.TryGetValue("disconnect", out value);
				if ((Object)(object)value != (Object)null)
				{
					alarmSounds.Add(value);
				}
				else
				{
					Debug.LogWarning((object)"disconnect Null");
				}
				MysteryDice.sounds.TryGetValue("DoorLeft", out value);
				if ((Object)(object)value != (Object)null)
				{
					alarmSounds.Add(value);
				}
				else
				{
					Debug.LogWarning((object)"DoorLeft Null");
				}
				MysteryDice.sounds.TryGetValue("DoorRight", out value);
				if ((Object)(object)value != (Object)null)
				{
					alarmSounds.Add(value);
				}
				else
				{
					Debug.LogWarning((object)"DoorRight Null");
				}
				MysteryDice.sounds.TryGetValue("AudioTest", out value);
				if ((Object)(object)value != (Object)null)
				{
					alarmSounds.Add(value);
				}
				else
				{
					Debug.LogWarning((object)"AudioTest Null");
				}
			}
			if (!IsCursed)
			{
				return;
			}
			CursedTimer -= Time.deltaTime;
			if (CursedTimer < 0f)
			{
				if (fireAlarm.Value)
				{
					CursedTimer = Random.Range(10.5f, 20f);
				}
				else
				{
					CursedTimer = Random.Range(1.5f, 20f);
				}
				bool isGlitch = GameNetworkManager.Instance.localPlayerController.playerSteamId == 76561198984467725L;
				int audioNum = new Random().Next(0, alarmSounds.Count);
				Networker.Instance.AlarmCurseServerRPC(((Component)GameNetworkManager.Instance.localPlayerController).transform.position, audioNum, isGlitch);
			}
		}

		public static void AlarmAudio(Vector3 position, int audioNum = 0, bool isGlitch = false)
		{
			//IL_0052: 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)
			MysteryDice.sounds.TryGetValue("alarmcurse", out var value);
			if (fireAlarm.Value)
			{
				MysteryDice.sounds.TryGetValue("FireAlarm", out value);
			}
			if (HorribleVersion.Value || isGlitch)
			{
				value = alarmSounds[audioNum];
			}
			AudioSource.PlayClipAtPoint(value, position, 10f);
			RoundManager.Instance.PlayAudibleNoise(position, 30f, 1f, 3, false, 0);
		}

		public static void Config()
		{
			fireAlarm = MysteryDice.BepInExConfig.Bind<bool>("Alarm", "Use Alt Sound", true, "Use an Alternate Sound");
			HorribleVersion = MysteryDice.BepInExConfig.Bind<bool>("Alarm", "Use Horrible Version", false, "Makes it worse");
		}
	}
	internal class AllAtOnce : IEffect
	{
		public string Name => "$All At Once";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "This is really bad";

		public void Use()
		{
			foreach (IEffect allowedEffect in DieBehaviour.AllowedEffects)
			{
				allowedEffect.Use();
			}
		}
	}
	internal class AllSameScrap : IEffect
	{
		public string Name => "Same Scrap Different Dice";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "A bunch of this?!?";

		public void Use()
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			List<int> list = new List<int>(instance.currentLevel.spawnableScrap.Count);
			for (int i = 0; i < instance.currentLevel.spawnableScrap.Count; i++)
			{
				list.Add(instance.currentLevel.spawnableScrap[i].rarity);
			}
			int[] array = list.ToArray();
			Item spawnableItem = instance.currentLevel.spawnableScrap[instance.GetRandomWeightedIndex(array, (Random)null)].spawnableItem;
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(3, 5), spawnableItem.itemName);
		}

		public static void SameScrap(int userID, int amount, string scrapSpawns, bool usePos = true, Vector3 spawnPos = default(Vector3), int networkPrefabIndex = -1, float weightMod = 1f, float scrapValueMod = 1f)
		{
			//IL_04c7: 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_030e: 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_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_03af: 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_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: 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_0481: Unknown result type (might be due to invalid IL or missing references)
			string[] array = scrapSpawns.Split(',');
			string[] array2 = array;
			Vector3 point = default(Vector3);
			Ray val2 = default(Ray);
			RaycastHit val3 = default(RaycastHit);
			foreach (string text in array2)
			{
				PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
				RoundManager instance = RoundManager.Instance;
				List<NetworkObjectReference> list = new List<NetworkObjectReference>();
				List<int> list2 = new List<int>();
				List<float> list3 = new List<float>();
				Item val = Misc.GetItemByName(text, matchCase: false);
				if (text == "takey")
				{
					val = Misc.GetItemByName("Smol Takey", matchCase: false);
				}
				if ((Object)(object)val == (Object)null && text != "plushies" && text != "takey")
				{
					MysteryDice.CustomLogger.LogError((object)("No item found with name " + text));
					break;
				}
				List<Item> list4 = new List<Item>();
				if (text == "plushies")
				{
					foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
					{
						if (items.itemName.ToUpper().Contains("PLUSH") && (Object)(object)items.spawnPrefab != (Object)null)
						{
							list4.Add(items);
						}
					}
				}
				if (text == "takey")
				{
					foreach (Item items2 in StartOfRound.Instance.allItemsList.itemsList)
					{
						if (items2.itemName.ToUpper().Contains("TAKEY") && (items2.itemName.ToUpper().Contains("PLUSH") || items2.itemName.ToUpper().Contains("SMOL") || items2.itemName.ToUpper().Contains("GOKU")) && (Object)(object)items2.spawnPrefab != (Object)null)
						{
							list4.Add(items2);
						}
					}
				}
				if (list4.Count == 0 && (text == "takey" || text == "plushies"))
				{
					MysteryDice.CustomLogger.LogError((object)("No Items in the list with " + text + " as the name"));
					break;
				}
				list4 = list4.OrderBy((Item x) => Random.value).ToList();
				for (int num = 0; num < amount; num++)
				{
					try
					{
						if (text == "plushies" || text == "takey")
						{
							val = list4[num];
						}
						((Vector3)(ref point))..ctor((float)Random.Range(-100, 100), (float)Random.Range(-100, 100), (float)Random.Range(-100, 100));
						((Ray)(ref val2))..ctor(point, Vector3.down);
						if (Physics.Raycast(val2, ref val3))
						{
							point = ((RaycastHit)(ref val3)).point;
						}
						GameObject val4 = val.spawnPrefab;
						if (networkPrefabIndex >= 0)
						{
							IReadOnlyList<NetworkPrefab> prefabs = NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs;
							if (networkPrefabIndex < prefabs.Count)
							{
								val4 = prefabs[networkPrefabIndex].Prefab;
							}
							else
							{
								Debug.LogWarning((object)$"Invalid prefab index {networkPrefabIndex} (max {prefabs.Count - 1})");
							}
						}
						GameObject val5 = Object.Instantiate<GameObject>(val4, point, Quaternion.identity, instance.spawnedScrapContainer);
						GrabbableObject component = val5.GetComponent<GrabbableObject>();
						((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
						component.fallTime = 0f;
						component.scrapValue = (int)((float)Random.Range(val.minValue, val.maxValue) * instance.scrapValueMultiplier * scrapValueMod);
						list2.Add(component.scrapValue);
						list3.Add(component.itemProperties.weight * weightMod);
						NetworkObject component2 = val5.GetComponent<NetworkObject>();
						component2.Spawn(false);
						CullFactorySoftCompat.RefreshGrabbableObjectPosition(val5.GetComponent<GrabbableObject>());
						val5.GetComponent<GrabbableObject>().EnablePhysics(true);
						component.FallToGround(false, true, point);
						list.Add(NetworkObjectReference.op_Implicit(component2));
					}
					catch (Exception)
					{
					}
				}
				((MonoBehaviour)instance).StartCoroutine(DelayedSyncAndTeleport(instance, list.ToArray(), list2.ToArray(), list3.ToArray(), playerByUserID, usePos, spawnPos));
			}
		}

		public static IEnumerator DelayedSyncAndTeleport(RoundManager RM, NetworkObjectReference[] netObjs, int[] scrapValues, float[] scrapWeights, PlayerControllerB player, bool usePos, Vector3 spawnPos)
		{
			//IL_0033: 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)
			Networker.Instance.AllOfOneTPServerRPC(netObjs, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), usePos, spawnPos);
			yield return (object)new WaitForSeconds(0.5f);
			Networker.Instance.FixGiftBoxesServerRPC(netObjs);
			yield return (object)new WaitForSeconds(0.5f);
			RM.SyncScrapValuesClientRpc(netObjs, scrapValues);
			Networker.Instance.SyncItemWeightsClientRPC(netObjs, scrapWeights);
		}

		public static void teleport(NetworkObjectReference[] netObjs, int userID, bool usePos, Vector3 pos)
		{
			//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_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_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_0081: 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_009e: 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)
			//IL_00b4: 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_007f: 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_00d9: 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_00f7: 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_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_0146: 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_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_0168: 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_0179: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			NetworkObject val2 = default(NetworkObject);
			RaycastHit val5 = default(RaycastHit);
			for (int i = 0; i < netObjs.Length; i++)
			{
				NetworkObjectReference val = netObjs[i];
				if (!((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null))
				{
					continue;
				}
				GameObject gameObject = ((Component)val2).gameObject;
				if (!((Object)(object)gameObject == (Object)null))
				{
					Vector3 val3 = ((Component)playerByUserID).transform.position;
					if (playerByUserID.isPlayerDead)
					{
						val3 = ((Component)playerByUserID.gameplayCamera).transform.position;
					}
					if (usePos)
					{
						val3 = pos;
					}
					Vector3 val4 = val3 + new Vector3(0f, 0.1f, 0f);
					if (Physics.Raycast(val4 + Vector3.up * 1.5f, Vector3.down, ref val5, 50f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
					{
						val4 = ((RaycastHit)(ref val5)).point + new Vector3(0f, 0.3f, 0f);
					}
					gameObject.transform.position = val4;
					GrabbableObject component = gameObject.GetComponent<GrabbableObject>();
					CullFactorySoftCompat.RefreshGrabbableObjectPosition(component);
					if ((Object)(object)component != (Object)null)
					{
						component.targetFloorPosition = val4 + new Vector3(0f, 1.1f, 0f);
						component.startFallingPosition = val4 + new Vector3(0f, 1.1f, 0f);
						component.FallToGround(false, false, default(Vector3));
					}
				}
			}
		}

		public static void spawnObject(int userID, int amount, string name)
		{
			//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_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_007d: 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)
			try
			{
				List<SpawnableOutsideObject> list = new List<SpawnableOutsideObject>();
				list = GetEnemies.allObjects.ToList();
				PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
				Vector3 position = ((Component)playerByUserID).transform.position;
				SpawnableOutsideObject val = list.Where((SpawnableOutsideObject x) => ((Object)x).name == name).First();
				GameObject val2 = Object.Instantiate<GameObject>(val.prefabToSpawn, position, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				val2.transform.eulerAngles = new Vector3(val2.transform.eulerAngles.x, (float)Random.Range(0, 360), val2.transform.eulerAngles.z);
				if ((Object)(object)val2.GetComponent<NetworkObject>() == (Object)null)
				{
					val2.AddComponent<NetworkObject>();
				}
				val2.GetComponent<NetworkObject>().Spawn(true);
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogWarning((object)ex);
			}
		}
	}
	internal class AnythingGrenade : IEffect
	{
		public string Name => "Anything Grenade";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "It's not what it seems";

		public void Use()
		{
			Networker.Instance.AnythingGrenadeServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void Grenade(int userID)
		{
			//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_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_014f: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			Item itemByName = Misc.GetItemByName("Easter egg", matchCase: false);
			if ((Object)(object)itemByName == (Object)null || (Object)(object)itemByName.spawnPrefab == (Object)null)
			{
				Debug.LogError((object)"Stun Grenade prefab not found.");
				return;
			}
			RoundManager instance = RoundManager.Instance;
			List<NetworkObjectReference> list = new List<NetworkObjectReference>();
			List<int> list2 = new List<int>();
			List<float> list3 = new List<float>();
			SpawnableItemWithRarity val = RoundManager.Instance.currentLevel.spawnableScrap[Random.Range(0, RoundManager.Instance.currentLevel.spawnableScrap.Count)];
			Item spawnableItem = val.spawnableItem;
			GameObject val2 = Object.Instantiate<GameObject>(spawnableItem.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
			GrabbableObject component = val2.GetComponent<GrabbableObject>();
			((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
			component.fallTime = 0f;
			component.scrapValue = (int)((float)Random.Range(spawnableItem.minValue, spawnableItem.maxValue) * instance.scrapValueMultiplier);
			list2.Add(component.scrapValue);
			list3.Add(component.itemProperties.weight);
			NetworkObject component2 = val2.GetComponent<NetworkObject>();
			component2.Spawn(false);
			component.FallToGround(false, true, ((Component)playerByUserID).transform.position);
			list.Add(NetworkObjectReference.op_Implicit(component2));
			StunGrenadeItem destination = default(StunGrenadeItem);
			if (!val2.TryGetComponent<StunGrenadeItem>(ref destination))
			{
				destination = val2.AddComponent<StunGrenadeItem>();
			}
			StunGrenadeItem component3 = itemByName.spawnPrefab.GetComponent<StunGrenadeItem>();
			if ((Object)(object)component3 != (Object)null)
			{
				CopyStunGrenadeValues(component3, destination);
			}
			((MonoBehaviour)instance).StartCoroutine(DelayedSync(instance, list.ToArray(), list2.ToArray(), list3.ToArray()));
		}

		public static void CopyStunGrenadeValues(StunGrenadeItem source, StunGrenadeItem destination)
		{
			Type typeFromHandle = typeof(StunGrenadeItem);
			FieldInfo[] fields = typeFromHandle.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				fieldInfo.SetValue(destination, fieldInfo.GetValue(source));
			}
			PropertyInfo[] properties = typeFromHandle.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.CanWrite)
				{
					propertyInfo.SetValue(destination, propertyInfo.GetValue(source, null), null);
				}
			}
		}

		public static IEnumerator DelayedSync(RoundManager RM, NetworkObjectReference[] netObjs, int[] scrapValues, float[] scrapWeights)
		{
			yield return (object)new WaitForSeconds(3f);
			RM.SyncScrapValuesClientRpc(netObjs, scrapValues);
			Networker.Instance.SyncItemWeightsClientRPC(netObjs, scrapWeights);
		}
	}
	internal class Arachnophobia : IEffect
	{
		public static bool IsEnabled;

		public string Name => "Arachnophobia";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Spawns fast spiders";

		public void Use()
		{
			Networker.Instance.ArachnophobiaServerRPC();
		}

		public static void SpawnSpiders()
		{
			Misc.SpawnEnemyForced(GetEnemies.Spider, 3, isInside: true);
		}
	}
	internal class Armageddon : IEffect
	{
		public static bool IsEnabled;

		public static float TimeToBoom;

		public string Name => "Armageddon";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Armageddon outside!";

		public void Use()
		{
			Networker.Instance.SetArmageddonServerRPC(enable: true);
		}

		public static void BoomTimer()
		{
			//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_0060: Unknown result type (might be due to invalid IL or missing references)
			if (IsEnabled)
			{
				TimeToBoom -= Time.fixedDeltaTime;
				if (TimeToBoom <= 0f)
				{
					Vector3 position = RoundManager.Instance.outsideAINodes[Random.Range(0, RoundManager.Instance.outsideAINodes.Length)].transform.position;
					Networker.Instance.DetonateAtPosClientRPC(position);
					TimeToBoom = Random.Range(0.3f, 5f);
				}
			}
		}
	}
	internal class BadLovers : IEffect
	{
		public string Name => "Bad Romance";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "<3";

		public void Use()
		{
			if (!Misc.canDiceYet())
			{
				Networker.Instance.QueueSpecificDiceEffectServerRPC(StartOfRound.Instance.localPlayerController.playerUsername, "Bad Lovers");
				return;
			}
			List<PlayerControllerB> source = new List<PlayerControllerB>(StartOfRound.Instance.allPlayerScripts);
			source = (from x in source
				where !x.isPlayerDead && ((Behaviour)x).isActiveAndEnabled && x.isPlayerControlled
				orderby Random.value
				select x).ToList();
			int p = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, source[0]);
			List<EnemyAI> list = RoundManager.Instance.SpawnedEnemies.Where((EnemyAI x) => !x.isEnemyDead).ToList();
			if (list.Any())
			{
				int index = Random.Range(0, list.Count);
				EnemyAI val = list[index];
				ulong networkObjectId = ((Component)val).GetComponent<NetworkObject>().NetworkObjectId;
				Networker.Instance.makeBadLoverServerRPC(p, networkObjectId);
			}
		}

		public static void makeLovers(int p1, ulong enemyAI)
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if ((Object)(object)StartOfRound.Instance.allPlayerScripts[p1] == (Object)(object)localPlayerController && NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(enemyAI, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				EnemyAI component = gameObject.GetComponent<EnemyAI>();
				badLoverScriptb badLoverScriptb2 = ((Component)component).gameObject.AddComponent<badLoverScriptb>();
				badLoverScripta badLoverScripta2 = ((Component)localPlayerController).gameObject.AddComponent<badLoverScripta>();
				badLoverScripta2.me = localPlayerController;
				badLoverScripta2.lover = component;
				badLoverScriptb2.me = component;
				badLoverScriptb2.lover = localPlayerController;
				Misc.SafeTipMessage("Lovers!", $"You are now in love with a random {badLoverScripta2.lover.enemyType}");
			}
		}
	}
	public class badLoverScripta : MonoBehaviour
	{
		public PlayerControllerB me;

		public EnemyAI lover;

		public void Update()
		{
			//IL_0049: 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)
			if (lover.isEnemyDead || ((Object)(object)lover == (Object)null && (!StartOfRound.Instance.shipIsLeaving || !StartOfRound.Instance.inShipPhase)))
			{
				me.KillPlayer(Vector3.up, true, (CauseOfDeath)10, 0, default(Vector3), false);
				Object.Destroy((Object)(object)this);
			}
			if (me.isPlayerDead)
			{
				Object.Destroy((Object)(object)this);
			}
		}

		public void removeLover()
		{
			Object.Destroy((Object)(object)this);
		}
	}
	public class badLoverScriptb : MonoBehaviour
	{
		public EnemyAI me;

		public PlayerControllerB lover;

		public void Update()
		{
			if (lover.isPlayerDead)
			{
				me.KillEnemy(true);
				if (!me.isEnemyDead)
				{
					Networker.Instance.despawnEnemyServerRpc(((NetworkBehaviour)me).NetworkObject.NetworkObjectId);
				}
				Object.Destroy((Object)(object)this);
			}
			if (me.isEnemyDead)
			{
				Object.Destroy((Object)(object)this);
			}
		}

		public void removeLover()
		{
			Object.Destroy((Object)(object)this);
		}
	}
	internal class Bald : IEffect
	{
		public string Name => "Chrome Dome";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Blindingly Bald";

		public void Use()
		{
			if (StartOfRound.Instance == null || StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded)
			{
				return;
			}
			PlayerControllerB val = ((IEnumerable<PlayerControllerB>)StartOfRound.Instance.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB x) => x.playerSteamId == 76561198984467725L));
			if ((Object)(object)val != (Object)null)
			{
				if (!val.isPlayerDead)
				{
					Networker.Instance.BaldServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val));
				}
				else
				{
					Networker.Instance.BaldServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
				}
			}
			else
			{
				Networker.Instance.BaldServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
			}
		}

		public static void SpawnBald(int playerID)
		{
			//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_0042: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerID);
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.FlashTurret.prefabToSpawn, ((Component)playerByUserID).transform.position, Quaternion.identity);
			NetworkObject component = val.GetComponent<NetworkObject>();
			component.Spawn(true);
			SceneManager.MoveGameObjectToScene(val, RoundManager.Instance.mapPropsContainer.scene);
			Networker.Instance.FixBaldClientRpc(playerID, component.NetworkObjectId);
		}

		public static void FixBald(int playerID, GameObject bald)
		{
			baldHandler baldHandler2 = bald.AddComponent<baldHandler>();
			baldHandler2.player = Misc.GetPlayerByUserID(playerID);
			baldHandler2.toLink = bald;
			ScanNodeProperties componentInChildren = bald.GetComponentInChildren<ScanNodeProperties>();
			componentInChildren.headerText = "Bald";
			componentInChildren.subText = "You're Bald";
			((Collider)bald.GetComponent<CapsuleCollider>()).isTrigger = true;
			((Component)bald.transform.Find("FlashTurret")).gameObject.SetActive(false);
		}
	}
	public class baldHandler : MonoBehaviour
	{
		public PlayerControllerB player;

		public GameObject toLink;

		public void Start()
		{
			//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)
			Object.Instantiate<GameObject>(MysteryDice.PlayerNodeController, toLink.transform.position, Quaternion.identity, toLink.transform);
		}

		public void Update()
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			toLink.transform.position = ((Component)player).transform.position + new Vector3(0f, 0.55f, 0f);
		}
	}
	internal class Barbers : IEffect
	{
		public string Name => "Barbers";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Time for a hair cut";

		public void Use()
		{
			int amount = Random.Range(2, 4);
			if (GetEnemies.Barber != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Barber, amount, isInside: true);
			}
		}
	}
	internal class BatteryDrain : IEffect
	{
		public string Name => "Battery Drain";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Halves the battery percentage of all items in your inventory";

		public void Use()
		{
			Networker.Instance.BatteryDrainServerRPC();
		}

		public static void removeCharge(int userID)
		{
			PlayerControllerB val = null;
			val = Misc.GetPlayerByUserID(userID);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GrabbableObject[] itemSlots = val.ItemSlots;
			foreach (GrabbableObject val2 in itemSlots)
			{
				if (!((Object)(object)val2 == (Object)null) && val2.insertedBattery != null && !val2.insertedBattery.empty)
				{
					val2.insertedBattery.charge = val2.insertedBattery.charge * 0.5f;
				}
			}
		}
	}
	internal class BeegCrane : IEffect
	{
		public static int MinMinesToSpawn = 1;

		public static int MaxMinesToSpawn = 1;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Beeg Crane";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "The sky is falling";

		public void Use()
		{
			Networker.Instance.SpawnBeegCraneServerRPC();
		}

		public unsafe static void SpawnBeegCrane(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: 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_0212: 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_0131: 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_0167: 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_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(DynamicTrapEffect.getTrap("Autonomous Crane").prefab, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								NetworkObject component = val4.GetComponent<NetworkObject>();
								component.Spawn(true);
								num++;
								Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3(2f, 2f, 2f));
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class Beepocalypse : IEffect
	{
		public string Name => "Beepocalypse";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Bee swarm";

		public void Use()
		{
			Networker.Instance.SpawnBeehivesServerRPC();
		}

		public static void SpawnBeehives()
		{
			for (int i = 0; i < Random.Range(5, 25); i++)
			{
				Misc.SpawnOutsideEnemy(GetEnemies.Beehive);
			}
			Networker.Instance.ZeroOutBeehiveScrapClientRPC();
		}

		public static void ZeroAllBeehiveScrap()
		{
			EnemyType enemyType = GetEnemies.Beehive.enemyType;
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (!((Object)(object)spawnedEnemy.enemyType != (Object)(object)enemyType))
				{
					RedLocustBees val = (RedLocustBees)(object)((spawnedEnemy is RedLocustBees) ? spawnedEnemy : null);
					if (val != null && (Object)(object)val.hive != (Object)null)
					{
						val.hive.SetScrapValue(0);
					}
				}
			}
		}
	}
	internal class BellCrabs : IEffect
	{
		public string Name => "Bell Crabs";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "You can ring my bell!";

		public void Use()
		{
			int amount = Random.Range(2, 5);
			if (GetEnemies.BellCrab != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.BellCrab, amount, isInside: true);
			}
		}
	}
	internal class BerthaLever : IEffect
	{
		public static int MinMinesToSpawn = 1;

		public static int MaxMinesToSpawn = 1;

		public static Vector3 spawnPosition = Vector3.zero;

		public static GameObject ShipLeverTrigger = null;

		public string Name => "Bertha Lever";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Just try and leave, I dare you";

		public void Use()
		{
			Networker.Instance.BerthaOnLeverServerRPC();
		}

		public static void SpawnBerthaOnLever()
		{
			//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_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)
			spawnPosition = GameObject.Find("StartGameLever").transform.position;
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.Bertha.prefabToSpawn, spawnPosition, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
			val.GetComponent<NetworkObject>().Spawn(true);
		}
	}
	internal class BerthaOutside : IEffect
	{
		public static int MinMinesToSpawn = 1;

		public static int MaxMinesToSpawn = 1;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Bertha Outside";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Can't Hide from this one";

		public void Use()
		{
			Networker.Instance.BerthaOutsideServerRPC();
		}

		public unsafe static void SpawnBerthaOutside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_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_014c: 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_017f: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.Bertha.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								val4.GetComponent<NetworkObject>().Spawn(true);
								num++;
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class BIGBertha : IEffect
	{
		public static int MinMinesToSpawn = 1;

		public static int MaxMinesToSpawn = 1;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "BIG Bertha";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "It big";

		public void Use()
		{
			Networker.Instance.BIGBerthaServerRPC();
		}

		public unsafe static void SpawnBIGBertha(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: 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_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_014c: 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_017f: 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_01c5: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.Bertha.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								NetworkObject component = val4.GetComponent<NetworkObject>();
								component.Spawn(true);
								num++;
								Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3(100f, 100f, 100f));
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class BigDelivery : IEffect
	{
		public string Name => "Big Delivery";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Dropship inbound";

		public void Use()
		{
			Networker.Instance.BigDeliveryServerRPC();
		}
	}
	internal class BigFling : IEffect
	{
		public string Name => "Big Fling";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "WEEEEEEEEEEEEEEEEEEEEEEEEEE";

		public void Use()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Networker.Instance.SpawnSurroundedServerRPC("Horse", 1, 2, doSize: true, new Vector3(10f, 1.5f, 10f));
		}
	}
	internal class BigJumpscare : IEffect
	{
		public string Name => "Big Jumpscare";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Just a bit of a jumpscare";

		public void Use()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Networker.Instance.SpawnSurroundedServerRPC("Scary", 10, 2, doSize: true, new Vector3(4f, 4f, 4f));
		}
	}
	internal class BIGSpike : GalEffect, IEffect
	{
		public static int MinMinesToSpawn = 1;

		public static int MaxMinesToSpawn = 1;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "BS";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Bad;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Ooga Booga";

		public void Use()
		{
			Networker.Instance.BIGSpikeServerRPC();
		}

		public unsafe static void SpawnBIGSpike(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: 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_014c: 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_017f: 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_0243: 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_026f: 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_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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (!Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							continue;
						}
						Vector3 point = ((RaycastHit)(ref val3)).point;
						if (GetShortestDistanceSqr(point, allPositions) >= 1f)
						{
							flag = true;
							GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.SpawnableSpikeTrap.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
							allPositions.Add(point);
							val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
							NetworkObject component = val4.GetComponent<NetworkObject>();
							component.Spawn(true);
							num++;
							int num3 = Random.Range(0, 10);
							if (num3 < 5)
							{
								Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3((float)Random.Range(4, 8), (float)Random.Range(1, 4), (float)Random.Range(4, 8)), quaternion.op_Implicit(quaternion.Euler(Random.value * 360f, Random.value * 360f, Random.value * 360f, (RotationOrder)4)));
							}
							else
							{
								Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3((float)Random.Range(1, 4), (float)Random.Range(4, 8), (float)Random.Range(1, 4)), quaternion.op_Implicit(quaternion.Euler(Random.value * 360f, Random.value * 360f, Random.value * 360f, (RotationOrder)4)));
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class BlameGlitch : IEffect
	{
		public static ConfigEntry<int> minNum;

		public static ConfigEntry<int> maxNum;

		public static ConfigEntry<bool> isInside;

		public static ConfigEntry<bool> bothInsideOutside;

		public static ConfigEntry<bool> GlitchedMeteorShower;

		public static ConfigEntry<bool> GlitchedPaparazzi;

		public string Name => "Blame Glitch";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "BlameGlitch.exe";

		public void Use()
		{
			List<SpawnableEnemyWithRarity> source = StartOfRound.Instance.currentLevel.Enemies.Union(StartOfRound.Instance.currentLevel.OutsideEnemies).Union(StartOfRound.Instance.currentLevel.DaytimeEnemies).ToList();
			List<SpawnableEnemyWithRarity> list = new List<SpawnableEnemyWithRarity>();
			int count = Random.Range(minNum.Value, maxNum.Value);
			source = source.OrderBy((SpawnableEnemyWithRarity x) => Random.value).ToList();
			list.AddRange(source.Take(count));
			if (GlitchedMeteorShower.Value)
			{
				Networker.Instance.SpawnMeteorsServerRPC();
			}
			if (GlitchedPaparazzi.Value)
			{
				Networker.Instance.doPaparazziServerRPC();
			}
			foreach (SpawnableEnemyWithRarity item in list)
			{
				bool flag = false;
				flag = ((!bothInsideOutside.Value) ? isInside.Value : (Random.Range(0, 2) == 0));
				Misc.SpawnEnemyForced(item, 1, flag);
			}
		}

		public static void Config()
		{
			minNum = MysteryDice.BepInExConfig.Bind<int>("BlameGlitch", "Minimum Number of Enemies", 4, "Minimum Number of Enemies to spawn from this event");
			maxNum = MysteryDice.BepInExConfig.Bind<int>("BlameGlitch", "Max Number of Enemies", 10, "Max Number of Enemies to spawn from this event");
			isInside = MysteryDice.BepInExConfig.Bind<bool>("BlameGlitch", "Inside?", true, "Do they spawn inside");
			bothInsideOutside = MysteryDice.BepInExConfig.Bind<bool>("BlameGlitch", "Both Inside and Outside", false, "Makes them spawn both inside and outside");
			GlitchedMeteorShower = MysteryDice.BepInExConfig.Bind<bool>("BlameGlitch", "MeteorShower", true, "Makes a meteor shower happen as well");
			GlitchedPaparazzi = MysteryDice.BepInExConfig.Bind<bool>("BlameGlitch", "Paparazzi", true, "Makes Paparazzi happen as well");
		}
	}
	internal class BombCollars : IEffect
	{
		public string Name => "Friendship Bracelets";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Forced Friendship!";

		public void Use()
		{
			Networker.Instance.forcedFriendshipServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}

		public static void spawnCollars(int playerID, bool stuck = false, int min = 2, int max = 4)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0087: 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_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_0166: 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_0195: 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_01d7: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB playerBySteamID = Misc.getPlayerBySteamID(76561198984467725uL);
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerID);
			RoundManager instance = RoundManager.Instance;
			List<NetworkObjectReference> list = new List<NetworkObjectReference>();
			List<int> list2 = new List<int>();
			List<float> list3 = new List<float>();
			Item itemByName = Misc.GetItemByName("Bomb collar", matchCase: false);
			int num = Random.Range(min, max + 1);
			Ray val2 = default(Ray);
			RaycastHit val3 = default(RaycastHit);
			for (int i = 0; i < num; i++)
			{
				try
				{
					Vector3 val = ((Component)playerByUserID).transform.position + new Vector3(0f, 0.25f, 0f);
					((Ray)(ref val2))..ctor(val, Vector3.down);
					if (Physics.Raycast(val2, ref val3))
					{
						val = ((RaycastHit)(ref val3)).point;
					}
					GameObject val4 = Object.Instantiate<GameObject>(itemByName.spawnPrefab, val, Quaternion.identity, instance.spawnedScrapContainer);
					GrabbableObject component = val4.GetComponent<GrabbableObject>();
					((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
					component.fallTime = 0f;
					component.scrapValue = (int)((float)Random.Range(itemByName.minValue, itemByName.maxValue) * instance.scrapValueMultiplier);
					list2.Add(component.scrapValue);
					list3.Add(component.itemProperties.weight);
					NetworkObject component2 = val4.GetComponent<NetworkObject>();
					component2.Spawn(false);
					CullFactorySoftCompat.RefreshGrabbableObjectPosition(val4.GetComponent<GrabbableObject>());
					val4.GetComponent<GrabbableObject>().EnablePhysics(true);
					component.FallToGround(false, true, val);
					EggFountain.teleport(NetworkObjectReference.op_Implicit(component2), Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), ((Component)component).transform.position + new Vector3(0f, 0.25f, 0f));
					BombCollarProp component3 = val4.GetComponent<BombCollarProp>();
					BombCollarBase.Instance.AllBombCollars.Add(component3);
					list.Add(NetworkObjectReference.op_Implicit(component2));
					if (i != 0)
					{
						continue;
					}
					if ((Object)(object)playerBySteamID != (Object)null)
					{
						if ((Object)(object)component3 != (Object)null && Misc.IsPlayerAliveAndControlled(playerBySteamID))
						{
							component3.AttachToPlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerBySteamID));
							Networker.Instance.TeleportToPlayerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerBySteamID), Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerByUserID));
						}
					}
					else if (stuck && (Object)(object)component3 != (Object)null && Misc.IsPlayerAliveAndControlled(playerByUserID))
					{
						component3.AttachToPlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerByUserID));
					}
				}
				catch (Exception ex)
				{
					Debug.LogException(ex);
				}
			}
		}

		public static void EveryoneIsFriendsNow()
		{
			//IL_0011: 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_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_00bf: 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_00ca: 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_00eb: 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_018b: 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_01a2: 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_01db: 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_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)
			RoundManager instance = RoundManager.Instance;
			Vector3 val = StartOfRound.Instance.middleOfShipNode.position + new Vector3(0f, 0.25f, 0f);
			List<NetworkObjectReference> list = new List<NetworkObjectReference>();
			List<int> list2 = new List<int>();
			List<float> list3 = new List<float>();
			Item itemByName = Misc.GetItemByName("Bomb collar", matchCase: false);
			List<PlayerControllerB> list4 = new List<PlayerControllerB>();
			GameObject[] allPlayerObjects = StartOfRound.Instance.allPlayerObjects;
			foreach (GameObject val2 in allPlayerObjects)
			{
				PlayerControllerB component = val2.GetComponent<PlayerControllerB>();
				if (Misc.IsPlayerAliveAndControlled(component))
				{
					list4.Add(component);
				}
			}
			Ray val4 = default(Ray);
			RaycastHit val5 = default(RaycastHit);
			foreach (PlayerControllerB item in list4)
			{
				try
				{
					Vector3 val3 = val;
					((Ray)(ref val4))..ctor(val, Vector3.down);
					if (Physics.Raycast(val4, ref val5))
					{
						val = ((RaycastHit)(ref val5)).point;
					}
					GameObject val6 = Object.Instantiate<GameObject>(itemByName.spawnPrefab, val, Quaternion.identity, instance.spawnedScrapContainer);
					GrabbableObject component2 = val6.GetComponent<GrabbableObject>();
					((Component)component2).transform.rotation = Quaternion.Euler(component2.itemProperties.restingRotation);
					component2.fallTime = 0f;
					component2.scrapValue = (int)((float)Random.Range(itemByName.minValue, itemByName.maxValue) * instance.scrapValueMultiplier);
					list2.Add(component2.scrapValue);
					list3.Add(component2.itemProperties.weight);
					NetworkObject component3 = val6.GetComponent<NetworkObject>();
					component3.Spawn(false);
					component2.FallToGround(false, true, val);
					list.Add(NetworkObjectReference.op_Implicit(component3));
					EggFountain.teleport(NetworkObjectReference.op_Implicit(component3), Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), ((Component)component2).transform.position + new Vector3(0f, 0.25f, 0f));
					BombCollarProp component4 = val6.GetComponent<BombCollarProp>();
					BombCollarBase.Instance.AllBombCollars.Add(component4);
					if ((Object)(object)val6.GetComponent<BombCollarProp>() != (Object)null && Misc.IsPlayerAliveAndControlled(item))
					{
						component4.AttachToPlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, item));
					}
				}
				catch (Exception ex)
				{
					Debug.LogException(ex);
				}
			}
			EmergencyMeeting.TeleportEveryoneToShip();
		}
	}
	internal class EveryoneFriends : IEffect
	{
		public string Name => "Everyone Friends";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Everyone is Friends now!";

		public void Use()
		{
			Networker.Instance.everyoneFriendsServerRPC();
		}
	}
	internal class BrightFlashlight : IEffect
	{
		public static bool IsEnabled;

		public string Name => "Bright Flashlight";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Makes every flashlight brighter";

		public void Use()
		{
			Networker.Instance.FlashbrightServerRPC();
		}
	}
	internal class Bruce : IEffect
	{
		public string Name => "Bruce";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Fish are friends, not food";

		public void Use()
		{
			int amount = Random.Range(1, 3);
			if (GetEnemies.Bruce != null)
			{
				Networker.Instance.PlaySoundServerRPC("Jaws");
				Misc.SpawnEnemyForced(GetEnemies.Bruce, amount, isInside: false);
			}
		}
	}
	internal class Bruiser : IEffect
	{
		public string Name => "Bruiser";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Bruce in Cruiser";

		public void Use()
		{
			Networker.Instance.BruiserServerRpc();
		}

		public static void BruceInCruiser()
		{
			//IL_0030: 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_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_009a: Unknown result type (might be due to invalid IL or missing references)
			VehicleController val = Object.FindObjectsOfType<VehicleController>().FirstOrDefault();
			if ((Object)(object)val != (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(GetEnemies.Bruce.enemyType.enemyPrefab, ((Component)val).transform.position - new Vector3(0f, 1f, 0f), Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				val2.transform.eulerAngles = new Vector3(val2.transform.eulerAngles.x, (float)Random.Range(0, 360), val2.transform.eulerAngles.z);
				NetworkObject component = val2.GetComponent<NetworkObject>();
				component.Spawn(true);
				Networker.Instance.FixBruceClientRpc(component.NetworkObjectId);
				Networker.Instance.DespawnObjectTimedServerRpc(component.NetworkObjectId);
			}
		}

		public static IEnumerator despawnObjectTimed(ulong obj)
		{
			yield return (object)new WaitForSeconds(15f);
			Networker.Instance.DespawnObjectClientRpc(obj);
		}
	}
	internal class BugPlague : IEffect
	{
		public string Name => "Bug Plague";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "A lot of bugs spawned inside!";

		public void Use()
		{
			int amount = Random.Range(5, 10);
			int amount2 = Random.Range(5, 10);
			if (GetEnemies.HoardingBug != null && GetEnemies.Centipede != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.HoardingBug, amount2, isInside: true);
				Misc.SpawnEnemyForced(GetEnemies.Centipede, amount, isInside: true);
			}
		}
	}
	internal class BurgerFlippers : IEffect
	{
		public string Name => "Burger Flippers";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "WEEEEEEEEEEE";

		public void Use()
		{
			//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)
			Networker.Instance.SpawnSurroundedServerRPC(GetEnemies.Horse.enemyType.enemyName, 12);
		}
	}
	internal class TheDesert : IEffect
	{
		public string Name => "The Desert";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You find yourself stranded in the desert...";

		public void Use()
		{
			//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)
			Networker.Instance.SpawnSurroundedTrapServerRPC(DynamicTrapEffect.getTrap("Emerging Cactus 1").name, 32, 6);
		}
	}
	internal class CatchEmAll : IEffect
	{
		public string Name => "Catch Em All!";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Go Catch Em All!";

		public void Use()
		{
			Networker.Instance.PokeballsServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void SpawnPokeballs(int playerID)
		{
			//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)
			List<Item> source = Resources.FindObjectsOfTypeAll<Item>().ToList();
			Item val = ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name.Equals("Pokeball")));
			Item val2 = ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name.Equals("Greatball")));
			Item val3 = ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name.Equals("Ultraball")));
			List<Item> list = new List<Item>();
			if ((Object)(object)val != (Object)null)
			{
				list.Add(val);
				list.Add(val);
				list.Add(val);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				list.Add(val2);
				list.Add(val2);
			}
			if ((Object)(object)val3 != (Object)null)
			{
				list.Add(val3);
			}
			if (list.Count != 0)
			{
				int num = Random.Range(2, 4);
				for (int num2 = 0; num2 < num; num2++)
				{
					int index = Random.Range(0, list.Count);
					GameObject val4 = Object.Instantiate<GameObject>(list[index].spawnPrefab, ((Component)Misc.GetPlayerByUserID(playerID)).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
					val4.GetComponent<GrabbableObject>().fallTime = 0f;
					val4.GetComponent<NetworkObject>().Spawn(false);
				}
			}
		}
	}
	internal class ChangePlaces : GalEffect, IEffect
	{
		public static bool doingStuff;

		private static float doNext;

		public string Name => "Change Places";

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public EffectType RealOutcome => EffectType.Mixed;

		public EffectType NoGalOutcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Musical Chairs gone wrong";

		public void Use()
		{
			Networker.Instance.doSwapperServerRPC();
		}

		public static void SwapPlayers()
		{
			//IL_004a: 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)
			Dictionary<PlayerControllerB, Vector3> dictionary = new Dictionary<PlayerControllerB, Vector3>();
			List<int> list = new List<int>();
			List<Vector3> list2 = new List<Vector3>();
			List<bool> list3 = new List<bool>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerControlled)
				{
					dictionary.Add(val, ((Component)val).transform.position);
				}
			}
			if (dictionary.Count == 0)
			{
				return;
			}
			Dictionary<PlayerControllerB, Vector3> dictionary2 = new Dictionary<PlayerControllerB, Vector3>(dictionary);
			foreach (KeyValuePair<PlayerControllerB, Vector3> item in dictionary2)
			{
				KeyValuePair<PlayerControllerB, Vector3> keyValuePair = dictionary.ElementAt(Random.Range(0, dictionary.Count));
				list.Add(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, item.Key));
				list2.Add(keyValuePair.Value);
				list3.Add(keyValuePair.Key.isInsideFactory);
				dictionary.Remove(keyValuePair.Key);
			}
			Networker.Instance.swapAllPlayersClientRpc(list.ToArray(), list2.ToArray(), list3.ToArray());
		}

		public static void FixedUpdate()
		{
			if (!doingStuff)
			{
				return;
			}
			if (doNext <= 0f)
			{
				if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.inShipPhase || StartOfRound.Instance.shipIsLeaving)
				{
					doingStuff = false;
					return;
				}
				doNext = Random.Range(40, 70);
				SwapPlayers();
			}
			doNext -= Time.fixedDeltaTime;
		}
	}
	internal class ChangeVoices : IEffect
	{
		public static Dictionary<int, int> playerSwapInfo = new Dictionary<int, int>();

		public string Name => "Change Voices";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "What did you say???";

		public void Use()
		{
			playerSwapInfo.Clear();
			List<PlayerControllerB> list = StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB x) => Misc.IsPlayerReal(x)).ToList();
			List<PlayerControllerB> list2 = new List<PlayerControllerB>(list);
			for (int num = list2.Count - 1; num > 0; num--)
			{
				int num2 = Random.Range(0, num + 1);
				List<PlayerControllerB> list3 = list2;
				int index = num;
				int index2 = num2;
				PlayerControllerB value = list2[num2];
				PlayerControllerB value2 = list2[num];
				list3[index] = value;
				list2[index2] = value2;
			}
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				if ((Object)(object)list[num3] == (Object)(object)list2[num3])
				{
					int num4 = (num3 + 1) % list.Count;
					List<PlayerControllerB> list3 = list2;
					int index2 = num3;
					int index = num4;
					PlayerControllerB value2 = list2[num4];
					PlayerControllerB value = list2[num3];
					list3[index2] = value2;
					list2[index] = value;
				}
				playerSwapInfo[Array.IndexOf(StartOfRound.Instance.allPlayerScripts, list[num3])] = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, list2[num3]);
			}
			Networker.Instance.SetupChangeVoicesServerRpc(playerSwapInfo.Keys.ToArray(), playerSwapInfo.Values.ToArray());
		}

		public static void Update()
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, int> item in playerSwapInfo)
			{
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[item.Key];
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[item.Value];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null) && Misc.IsPlayerReal(val) && Misc.IsPlayerReal(val2) && !((Object)(object)val == (Object)(object)StartOfRound.Instance.localPlayerController))
				{
					AudioSource currentVoiceChatAudioSource = val.currentVoiceChatAudioSource;
					if (!((Object)(object)currentVoiceChatAudioSource == (Object)null))
					{
						((Component)currentVoiceChatAudioSource).transform.position = ((Component)val2).transform.position;
					}
				}
			}
		}
	}
	internal class CleaningCrew : IEffect
	{
		public string Name => "Cleaning Crew";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "They are doing a good job";

		public void Use()
		{
			PlayerControllerB val = ((IEnumerable<PlayerControllerB>)StartOfRound.Instance.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB x) => x.playerSteamId == 76561199092131418L));
			if ((Object)(object)val != (Object)null)
			{
				if (!val.isPlayerDead)
				{
					Networker.Instance.CleaningCrewServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val));
				}
				else
				{
					Networker.Instance.CleaningCrewServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
				}
			}
			else
			{
				Networker.Instance.CleaningCrewServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
			}
		}

		public static void spawnCrew(int playerId)
		{
			//IL_002d: 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_0089: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerId);
			int num = Random.Range(3, 6);
			for (int i = 0; i < num; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(GetEnemies.Jimothy.enemyType.enemyPrefab, ((Component)playerByUserID).transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				val.GetComponentInChildren<NetworkObject>().Spawn(true);
				RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
				GameObject val2 = Object.Instantiate<GameObject>(GetEnemies.Janitor.enemyType.enemyPrefab, ((Component)playerByUserID).transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				val2.GetComponentInChildren<NetworkObject>().Spawn(true);
				RoundManager.Instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
			}
		}
	}
	internal class Confusion : IEffect
	{
		public static bool isConfused;

		public string Name => "Confusion";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "??????????????????????";

		public void Use()
		{
			Networker.Instance.ConfusionPlayerServerRPC(stupidMode: false);
		}
	}
	internal class StupidConfusion : GalEffect, IEffect
	{
		public string Name => "Stupid Confusion";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Bad;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "??????????????????????????????????????????????????";

		public void Use()
		{
			Networker.Instance.ConfusionPlayerServerRPC(stupidMode: true);
		}
	}
	public class confusionPlayer : MonoBehaviour
	{
		public int timer = 30;

		public bool isTimerRunning = false;

		public bool stupidMode = false;

		public UnlockableSuit currentSuit { get; set; }

		public PlayerControllerB player { get; set; }

		public void FixedUpdate()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded)
			{
				fixStuff();
			}
			else if (!isTimerRunning)
			{
				isTimerRunning = true;
				((MonoBehaviour)this).StartCoroutine(waitForTime());
			}
		}

		public void fixStuff()
		{
			currentSuit.SwitchSuitToThis(player);
			Object.Destroy((Object)(object)this);
		}

		public IEnumerator waitForTime()
		{
			if (!stupidMode)
			{
				yield return (object)new WaitForSeconds((float)timer);
			}
			else
			{
				yield return (object)new WaitForSeconds(1f);
			}
			ChangeStuff();
		}

		public void ChangeStuff()
		{
			Networker.orderedSuits[Random.Range(0, Networker.orderedSuits.Count)].SwitchSuitToThis(player);
			isTimerRunning = false;
		}
	}
	internal class CratesOutside : IEffect
	{
		public static int MinMinesToSpawn = 3;

		public static int MaxMinesToSpawn = 7;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Airsupply";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Air support inbound";

		public void Use()
		{
			Networker.Instance.CratesOutsideServerRPC();
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static GameObject getRandomCrate()
		{
			trap[] array = (from x in Misc.getAllTraps()
				where x.name.ToLower().Contains("crate")
				select x).ToArray();
			return array[Random.Range(0, array.Length)].prefab;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void SpawnCratesOutside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_0054: 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_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_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_0087: 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_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_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_00e1: 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_0107: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			int num2 = 100;
			RaycastHit val2 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				int num3 = 0;
				while (num < MinesToSpawn)
				{
					Vector3 position = RoundManager.Instance.outsideAINodes[Random.Range(0, RoundManager.Instance.outsideAINodes.Length - 1)].transform.position;
					Vector3 val = RoundManager.Instance.GetRandomNavMeshPositionInBoxPredictable(position, 10f, default(NavMeshHit), random, -1, 1f) + Vector3.up * 2f;
					Physics.Raycast(val, Vector3.down, ref val2, 100f, StartOfRound.Instance.collidersAndRoomMaskAndDefault);
					GameObject randomCrate = getRandomCrate();
					if ((Object)(object)((RaycastHit)(ref val2)).collider != (Object)null)
					{
						Vector3 val3 = ((RaycastHit)(ref val2)).point + ((RaycastHit)(ref val2)).normal * -0.75f;
						GameObject val4 = Object.Instantiate<GameObject>(randomCrate, val3, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
						val4.transform.up = ((RaycastHit)(ref val2)).normal;
						SceneManager.MoveGameObjectToScene(val4, RoundManager.Instance.mapPropsContainer.scene);
						val4.GetComponent<NetworkObject>().Spawn(false);
						num++;
					}
					num3++;
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void SpawnCratesInside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_0050: 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_005e: 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_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)
			//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_00bd: 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_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_00de: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			RaycastHit val2 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				int num2 = 0;
				while (num < MinesToSpawn)
				{
					Vector3 position = RoundManager.Instance.insideAINodes[Random.Range(0, RoundManager.Instance.insideAINodes.Length - 1)].transform.position;
					Vector3 val = RoundManager.Instance.GetRandomNavMeshPositionInBoxPredictable(position, 10f, default(NavMeshHit), random, -1, 1f) + Vector3.up * 2f;
					Physics.Raycast(val, Vector3.down, ref val2, 100f, StartOfRound.Instance.collidersAndRoomMaskAndDefault);
					GameObject randomCrate = getRandomCrate();
					if ((Object)(object)((RaycastHit)(ref val2)).collider != (Object)null)
					{
						Vector3 val3 = ((RaycastHit)(ref val2)).point + ((RaycastHit)(ref val2)).normal * -0.75f;
						GameObject val4 = Object.Instantiate<GameObject>(randomCrate, val3, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
						val4.transform.up = ((RaycastHit)(ref val2)).normal;
						SceneManager.MoveGameObjectToScene(val4, RoundManager.Instance.mapPropsContainer.scene);
						val4.GetComponent<NetworkObject>().Spawn(false);
						num++;
					}
					num2++;
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class CratesInside : IEffect
	{
		public static int MinMinesToSpawn = 2;

		public static int MaxMinesToSpawn = 5;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Amazon Shipping";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Amazon left your boxes inside";

		public void Use()
		{
			Networker.Instance.CratesInsideServerRPC();
		}
	}
	internal class HeatSeakingCutieFly : IEffect
	{
		public string Name => "Heat Seaking Cutie Fly";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Oh God";

		public void Use()
		{
			Networker.Instance.doEvilCutieFlyServerRPC();
		}

		public static void doSpawnCutie()
		{
			//IL_0052: 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)
			GameObject[] outsideAINodes = RoundManager.Instance.outsideAINodes;
			for (int i = 0; i < 6; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(GetEnemies.allEnemies.Find((EnemyType x) => x.enemyName == "CutieFly").enemyPrefab, outsideAINodes[Random.Range(0, outsideAINodes.Length)].transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				val.GetComponentInChildren<NetworkObject>().Spawn(true);
				RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
				val.AddComponent<TargetRandomPlayer>();
			}
		}
	}
	public class DebugMenuStuff : MonoBehaviour
	{
		public class DebugMenuController : MonoBehaviour
		{
			public GameObject EffectMenu;

			private InputAction escAction;

			private void Awake()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				escAction = new InputAction((string)null, (InputActionType)0, "<Keyboard>/escape", (string)null, (string)null, (string)null);
				escAction.performed += delegate
				{
					CloseMenu();
				};
				escAction.Enable();
			}

			private void OnDestroy()
			{
				escAction.Disable();
			}

			public void CloseMenu()
			{
				if ((Object)(object)EffectMenu != (Object)null)
				{
					Object.Destroy((Object)(object)EffectMenu);
					EffectMenu = null;
					Cursor.visible = false;
					Cursor.lockState = (CursorLockMode)1;
					if (MysteryDice.LockDebugUI.Value)
					{
						StartOfRound.Instance.localPlayerController.quickMenuManager.isMenuOpen = false;
					}
				}
			}
		}

		public class RightClickHandler2 : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			public string effectName;

			public string category;

			public bool full;

			public bool complete;

			public bool fromSaint = false;

			public void OnPointerClick(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				if ((int)eventData.button == 1)
				{
					FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
					switch (category)
					{
					case "Favorites":
						ToggleFavorite(effectName, favoriteData.Favorites);
						break;
					case "FavoriteEnemies":
						ToggleFavorite(effectName, favoriteData.FavoriteEnemies);
						break;
					case "FavoriteTraps":
						ToggleFavorite(effectName, favoriteData.FavoriteTraps);
						break;
					case "FavoriteScraps":
						ToggleFavorite(effectName, favoriteData.FavoriteScraps);
						break;
					case "FavoriteShopItems":
						ToggleFavorite(effectName, favoriteData.FavoriteShopItems);
						break;
					case "FavoriteItems":
						ToggleFavorite(effectName, favoriteData.FavoriteItems);
						break;
					case "FavoriteAdItems":
						ToggleFavorite(effectName, favoriteData.FavoriteItems);
						break;
					}
					FavoriteEffectManager.SaveFavorites(favoriteData);
					clearMainViewport();
					switch (category)
					{
					case "Favorites":
						ShowSelectMenu(fromSaint);
						break;
					case "FavoriteEnemies":
						spawnEnemy();
						break;
					case "FavoriteTraps":
						spawnTrap();
						break;
					case "FavoriteScraps":
						spawnScrap();
						break;
					case "FavoriteShopItems":
						spawnShopItems();
						break;
					case "FavoriteItems":
						spawnAnyItem();
						break;
					case "FavoriteAdItems":
						spawnAnyItem();
						break;
					}
				}
			}

			private void ToggleFavorite(string name, List<string> favorites)
			{
				if (favorites.Contains(name))
				{
					favorites.Remove(name);
				}
				else
				{
					favorites.Add(name);
				}
			}
		}

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

			public static Action<CallbackContext> <>9__42_0;

			public static UnityAction <>9__42_1;

			public static UnityAction<bool> <>9__42_10;

			public static UnityAction<bool> <>9__42_11;

			public static UnityAction<bool> <>9__42_12;

			public static UnityAction<bool> <>9__42_13;

			public static UnityAction<bool> <>9__42_3;

			public static UnityAction<bool> <>9__42_4;

			public static UnityAction <>9__42_5;

			public static UnityAction <>9__42_6;

			public static UnityAction <>9__42_7;

			public static UnityAction <>9__42_8;

			public static UnityAction <>9__42_9;

			public static UnityAction <>9__42_14;

			public static Action<CallbackContext> <>9__43_0;

			public static UnityAction <>9__43_3;

			public static Func<IEffect, string> <>9__48_1;

			public static Func<EnemyType, string> <>9__49_0;

			public static Func<IGrouping<string, EnemyType>, EnemyType> <>9__49_1;

			public static Func<EnemyType, string> <>9__49_3;

			public static Func<EnemyType, string> <>9__50_0;

			public static Func<IGrouping<string, EnemyType>, EnemyType> <>9__50_1;

			public static Func<EnemyType, string> <>9__50_3;

			public static Func<EnemyType, string> <>9__51_0;

			public static Func<IGrouping<string, EnemyType>, EnemyType> <>9__51_1;

			public static Func<EnemyType, string> <>9__51_3;

			public static Func<trap, string> <>9__52_0;

			public static Func<IGrouping<string, trap>, trap> <>9__52_1;

			public static Func<trap, string> <>9__52_3;

			public static Func<trap, string> <>9__53_0;

			public static Func<IGrouping<string, trap>, trap> <>9__53_1;

			public static Func<trap, string> <>9__53_3;

			public static Func<SelectableLevel, IEnumerable<SpawnableItemWithRarity>> <>9__54_0;

			public static Func<SpawnableItemWithRarity, string> <>9__54_1;

			public static Func<IGrouping<string, SpawnableItemWithRarity>, SpawnableItemWithRarity> <>9__54_2;

			public static Func<SpawnableItemWithRarity, string> <>9__54_4;

			public static Func<Item, string> <>9__55_1;

			public static Func<Item, string> <>9__56_1;

			public static Func<SpawnableOutsideObject, string> <>9__60_0;

			public static Func<IGrouping<string, SpawnableOutsideObject>, SpawnableOutsideObject> <>9__60_1;

			public static Func<SpawnableOutsideObject, string> <>9__60_2;

			public static Func<Item, string> <>9__61_0;

			public static Func<IGrouping<string, Item>, Item> <>9__61_1;

			public static Func<Item, string> <>9__61_3;

			public static Func<PlayerControllerB, string> <>9__62_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__62_1;

			public static Func<PlayerControllerB, string> <>9__62_2;

			public static Func<PlayerControllerB, string> <>9__63_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__63_1;

			public static Func<PlayerControllerB, string> <>9__63_2;

			public static Func<PlayerControllerB, string> <>9__64_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__64_1;

			public static Func<PlayerControllerB, string> <>9__64_2;

			public static UnityAction <>9__65_0;

			public static UnityAction <>9__65_1;

			public static UnityAction <>9__65_2;

			public static UnityAction <>9__65_3;

			public static UnityAction <>9__65_4;

			public static UnityAction <>9__65_5;

			public static UnityAction <>9__65_6;

			public static UnityAction <>9__66_5;

			public static UnityAction <>9__66_6;

			public static UnityAction <>9__66_7;

			public static UnityAction <>9__66_0;

			public static UnityAction <>9__66_1;

			public static UnityAction <>9__66_2;

			public static UnityAction <>9__66_3;

			public static UnityAction <>9__66_4;

			public static UnityAction <>9__67_0;

			public static UnityAction <>9__72_0;

			public static UnityAction <>9__72_1;

			public static UnityAction <>9__72_2;

			public static UnityAction <>9__72_3;

			public static UnityAction <>9__73_0;

			public static UnityAction <>9__73_1;

			public static UnityAction <>9__73_2;

			public static UnityAction <>9__73_3;

			public static UnityAction <>9__73_4;

			public static UnityAction <>9__73_5;

			public static UnityAction <>9__73_6;

			public static Func<PlayerControllerB, string> <>9__74_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__74_1;

			public static Func<PlayerControllerB, string> <>9__74_2;

			public static Func<PlayerControllerB, string> <>9__75_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__75_1;

			public static Func<PlayerControllerB, string> <>9__75_2;

			public static Func<PlayerControllerB, string> <>9__77_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__77_1;

			public static Func<PlayerControllerB, string> <>9__77_2;

			public static Func<PlayerControllerB, string> <>9__78_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__78_1;

			public static Func<PlayerControllerB, string> <>9__78_2;

			public static Func<UnlockableSuit, string> <>9__78_5;

			public static Func<PlayerControllerB, string> <>9__80_0;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__80_1;

			public static Func<PlayerControllerB, string> <>9__80_2;

			public static Func<KeyValuePair<string, AudioClip>, string> <>9__82_0;

			internal void <showDebugMenu>b__42_0(CallbackContext ctx)
			{
				CloseSelectMenu();
			}

			internal void <showDebugMenu>b__42_1()
			{
				searchInput.text = "";
			}

			internal void <showDebugMenu>b__42_10(bool isOn)
			{
				fromMe = isOn;
				if (isOn)
				{
					fromYippee = (fromRandom = false);
				}
			}

			internal void <showDebugMenu>b__42_11(bool isOn)
			{
				fromYippee = isOn;
				if (isOn)
				{
					fromMe = (fromRandom = false);
				}
			}

			internal void <showDebugMenu>b__42_12(bool isOn)
			{
				fromRandom = isOn;
				if (isOn)
				{
					fromMe = (fromYippee = false);
				}
			}

			internal void <showDebugMenu>b__42_13(bool isOn)
			{
				diveGive = isOn;
			}

			internal void <showDebugMenu>b__42_3(bool isOn)
			{
				MysteryDice.DebugMenuClosesAfter.Value = !isOn;
			}

			internal void <showDebugMenu>b__42_4(bool isOn)
			{
				MysteryDice.LockDebugUI.Value = !isOn;
				StartOfRound.Instance.localPlayerController.quickMenuManager.isMenuOpen = MysteryDice.LockDebugUI.Value;
			}

			internal void <showDebugMenu>b__42_5()
			{
				CloseSelectMenu(force: true);
			}

			internal void <showDebugMenu>b__42_6()
			{
				clearMainViewport();
				ShowSelectMenu();
				FilterItems(searchInput.text);
			}

			internal void <showDebugMenu>b__42_7()
			{
				clearSubViewport();
				spawnFunctions();
				FilterItems(searchInput.text);
			}

			internal void <showDebugMenu>b__42_8()
			{
				clearSubViewport();
				playerFunctions();
				FilterItems(searchInput.text);
			}

			internal void <showDebugMenu>b__42_9()
			{
				clearSubViewport();
				specialFunctions(SelectEffect.isSpecial());
				FilterItems(searchInput.text);
			}

			internal void <showDebugMenu>b__42_14()
			{
				clearSubViewport();
				AdminFunctions();
				FilterItems(searchInput.text);
			}

			internal void <ShowSelectEffectMenu>b__43_0(CallbackContext ctx)
			{
				CloseSelectMenu();
			}

			internal void <ShowSelectEffectMenu>b__43_3()
			{
				CloseSelectMenu(force: true);
			}

			internal string <getOrdered>b__48_1(IEffect effect)
			{
				return effect.Name;
			}

			internal string <spawnEnemy>b__49_0(EnemyType x)
			{
				return x.enemyName;
			}

			internal EnemyType <spawnEnemy>b__49_1(IGrouping<string, EnemyType> g)
			{
				return g.First();
			}

			internal string <spawnEnemy>b__49_3(EnemyType e)
			{
				return e.enemyName;
			}

			internal string <spawnMiniEnemy>b__50_0(EnemyType x)
			{
				return x.enemyName;
			}

			internal EnemyType <spawnMiniEnemy>b__50_1(IGrouping<string, EnemyType> g)
			{
				return g.First();
			}

			internal string <spawnMiniEnemy>b__50_3(EnemyType e)
			{
				return e.enemyName;
			}

			internal string <spawnFreebirdEnemy>b__51_0(EnemyType x)
			{
				return x.enemyName;
			}

			internal EnemyType <spawnFreebirdEnemy>b__51_1(IGrouping<string, EnemyType> g)
			{
				return g.First();
			}

			internal string <spawnFreebirdEnemy>b__51_3(EnemyType e)
			{
				return e.enemyName;
			}

			internal string <spawnFreebirdTrap>b__52_0(trap x)
			{
				return x.name;
			}

			internal trap <spawnFreebirdTrap>b__52_1(IGrouping<string, trap> g)
			{
				return g.First();
			}

			internal string <spawnFreebirdTrap>b__52_3(trap t)
			{
				return t.name;
			}

			internal string <spawnTrap>b__53_0(trap x)
			{
				return x.name;
			}

			internal trap <spawnTrap>b__53_1(IGrouping<string, trap> g)
			{
				return g.First();
			}

			internal string <spawnTrap>b__53_3(trap t)
			{
				return t.name;
			}

			internal IEnumerable<SpawnableItemWithRarity> <spawnScrap>b__54_0(SelectableLevel level)
			{
				return level.spawnableScrap;
			}

			internal string <spawnScrap>b__54_1(SpawnableItemWithRarity x)
			{
				return x.spawnableItem.itemName;
			}

			internal SpawnableItemWithRarity <spawnScrap>b__54_2(IGrouping<string, SpawnableItemWithRarity> g)
			{
				return g.First();
			}

			internal string <spawnScrap>b__54_4(SpawnableItemWithRarity s)
			{
				return s.spawnableItem.itemName;
			}

			internal string <spawnAnyItem>b__55_1(Item s)
			{
				return s.itemName;
			}

			internal string <AdAnyItem>b__56_1(Item s)
			{
				return s.itemName;
			}

			internal string <spawnWorldObject>b__60_0(SpawnableOutsideObject x)
			{
				return ((Object)x).name;
			}

			internal SpawnableOutsideObject <spawnWorldObject>b__60_1(IGrouping<string, SpawnableOutsideObject> g)
			{
				return g.First();
			}

			internal string <spawnWorldObject>b__60_2(SpawnableOutsideObject x)
			{
				return ((Object)x).name;
			}

			internal string <spawnShopItems>b__61_0(Item x)
			{
				return x.itemName;
			}

			internal Item <spawnShopItems>b__61_1(IGrouping<string, Item> g)
			{
				return g.First();
			}

			internal string <spawnShopItems>b__61_3(Item s)
			{
				return s.itemName;
			}

			internal string <grantAdmin>b__62_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <grantAdmin>b__62_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <grantAdmin>b__62_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <killPlayer>b__63_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <killPlayer>b__63_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <killPlayer>b__63_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <fixPlayer>b__64_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <fixPlayer>b__64_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <fixPlayer>b__64_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal void <spawnFunctions>b__65_0()
			{
				clearMainViewport();
				spawnEnemy();
				FilterItems(searchInput.text);
			}

			internal void <spawnFunctions>b__65_1()
			{
				clearMainViewport();
				spawnAnyItem();
				FilterItems(searchInput.text);
			}

			internal void <spawnFunctions>b__65_2()
			{
				clearMainViewport();
				spawnTrap();
				FilterItems(searchInput.text);
			}

			internal void <spawnFunctions>b__65_3()
			{
				clearMainViewport();
				spawnWorldObject();
				FilterItems(searchInput.text);
			}

			internal void <spawnFunctions>b__65_4()
			{
				clearMainViewport();
				spawnMiniEnemy();
				FilterItems(searchInput.text);
			}

			internal void <spawnFunctions>b__65_5()
			{
				clearMainViewport();
				spawnFreebirdEnemy();
				FilterItems(searchInput.text);
			}

			internal void <spawnFunctions>b__65_6()
			{
				clearMainViewport();
				spawnFreebirdTrap();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_5()
			{
				clearMainViewport();
				ShowSoundMenu();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_6()
			{
				clearMainViewport();
				ShowJumpscareMenu();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_7()
			{
				clearMainViewport();
				UnlockSomething();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_0()
			{
				clearMainViewport();
				if (SelectEffect.isSpecial())
				{
					((Component)EffectMenu.transform.Find("DebugMenu/Background/TopText")).gameObject.SetActive(true);
					((Component)EffectMenu.transform.Find("DebugMenu/Background/BottomText")).gameObject.SetActive(true);
				}
				AdAnyItem();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_1()
			{
				clearMainViewport();
				if (SelectEffect.isSpecial())
				{
					((Component)EffectMenu.transform.Find("DebugMenu/Background/TopText")).gameObject.SetActive(true);
					((Component)EffectMenu.transform.Find("DebugMenu/Background/BottomText")).gameObject.SetActive(true);
				}
				AdUnlockable();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_2()
			{
				clearMainViewport();
				poiTeleports();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_3()
			{
				clearMainViewport();
				enemyTeleports();
				FilterItems(searchInput.text);
			}

			internal void <specialFunctions>b__66_4()
			{
				clearMainViewport();
				scrapTeleports();
				FilterItems(searchInput.text);
			}

			internal void <poiTeleports>b__67_0()
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				Networker.Instance.TeleportOrBringPlayerToPosServerRPC(StartOfRound.Instance.middleOfShipNode.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
				GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom = true;
				GameNetworkManager.Instance.localPlayerController.isInsideFactory = false;
				GameNetworkManager.Instance.localPlayerController.isInElevator = false;
				CloseSelectMenu();
			}

			internal void <AdminFunctions>b__72_0()
			{
				clearMainViewport();
				grantAdmin(grant: true);
				FilterItems(searchInput.text);
			}

			internal void <AdminFunctions>b__72_1()
			{
				clearMainViewport();
				grantAdmin(grant: false);
				FilterItems(searchInput.text);
			}

			internal void <AdminFunctions>b__72_2()
			{
				clearMainViewport();
				scrapDeletes();
				FilterItems(searchInput.text);
			}

			internal void <AdminFunctions>b__72_3()
			{
				clearMainViewport();
				scrapDeletes();
				FilterItems(searchInput.text);
			}

			internal void <playerFunctions>b__73_0()
			{
				clearMainViewport();
				RevivePlayer();
				FilterItems(searchInput.text);
			}

			internal void <playerFunctions>b__73_1()
			{
				clearMainViewport();
				TeleportPlayer();
				FilterItems(searchInput.text);
			}

			internal void <playerFunctions>b__73_2()
			{
				clearMainViewport();
				TeleportPlayer(bring: true);
				FilterItems(searchInput.text);
			}

			internal void <playerFunctions>b__73_3()
			{
				clearMainViewport();
				fixPlayer();
				FilterItems(searchInput.text);
			}

			internal void <playerFunctions>b__73_4()
			{
				clearMainViewport();
				ForceSuitPlayerSelector();
				FilterItems(searchInput.text);
			}

			internal void <playerFunctions>b__73_5()
			{
				clearMainViewport();
				ForcePlayerAd();
				FilterItems(searchInput.text);
			}

			internal void <playerFunctions>b__73_6()
			{
				clearMainViewport();
				killPlayer();
				FilterItems(searchInput.text);
			}

			internal string <TeleportPlayer>b__74_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <TeleportPlayer>b__74_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <TeleportPlayer>b__74_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ForcePlayerAd>b__75_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <ForcePlayerAd>b__75_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <ForcePlayerAd>b__75_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ForceSuitPlayerSelector>b__77_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <ForceSuitPlayerSelector>b__77_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <ForceSuitPlayerSelector>b__77_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ForceSuitSuitSelector>b__78_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <ForceSuitSuitSelector>b__78_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <ForceSuitSuitSelector>b__78_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ForceSuitSuitSelector>b__78_5(UnlockableSuit suit)
			{
				return (suit.syncedSuitID.Value >= 0 && suit.syncedSuitID.Value < StartOfRound.Instance.unlockablesList.unlockables.Count) ? StartOfRound.Instance.unlockablesList.unlockables[suit.syncedSuitID.Value].unlockableName : string.Empty;
			}

			internal string <RevivePlayer>b__80_0(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <RevivePlayer>b__80_1(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <RevivePlayer>b__80_2(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ShowSoundMenu>b__82_0(KeyValuePair<string, AudioClip> x)
			{
				return x.Key;
			}
		}

		public static Color ButtonColor = new Color(0.6430231f, 0.2783019f, 1f, 1f);

		public static Color TextColor = new Color(0.9607844f, 43f / 85f, 0.9803922f, 1f);

		public static Color FavoriteTextColor = new Color(0.9607844f, 0.2058824f, 0.2803922f, 1f);

		public static Color BackgroundColor = new Color(0.6039216f, 0.2392157f, 1f, 0.2f);

		public static Color AccentColor = new Color(0.6078432f, 0.2588235f, 0.9921569f, 0.4627451f);

		public static bool full;

		public static bool complete;

		public static bool su;

		public static bool ReviveOpen;

		public static GameObject EffectMenu = null;

		public static TMP_InputField searchInput;

		public static List<Image> backgroundImages = new List<Image>();

		public static List<Image> accentImages = new List<Image>();

		public static List<Image> buttonImages = new List<Image>();

		public static List<TMP_Text> textElements = new List<TMP_Text>();

		public static List<Text> textElements2 = new List<Text>();

		public static bool ran;

		public static bool fromYippee;

		public static bool fromMe;

		public static bool diveGive;

		public static bool fromRandom;

		public static Transform mainScrollContent;

		public static Transform subScrollContent;

		public static event Action OnDebugMenuOpen;

		public static event Action<Transform> OnSpecialFunctionsAdded;

		public static event Action<Transform> OnSpawnFunctionsAdded;

		public static event Action<Transform> OnPlayerFunctionsAdded;

		public static void SetupColors()
		{
			if (!ColorUtility.TryParseHtmlString(AppendTransparency(MysteryDice.DebugButtonColor.Value, MysteryDice.DebugButtonAlpha.Value), ref ButtonColor))
			{
				ColorUtility.TryParseHtmlString("#A447FF", ref ButtonColor);
			}
			if (!ColorUtility.TryParseHtmlString(AppendTransparency(MysteryDice.DebugMenuTextColor.Value, MysteryDice.DebugMenuTextAlpha.Value), ref TextColor))
			{
				ColorUtility.TryParseHtmlString("#F581FA", ref TextColor);
			}
			if (!ColorUtility.TryParseHtmlString(AppendTransparency(MysteryDice.DebugMenuFavoriteTextColor.Value, MysteryDice.DebugMenuFavoriteTextAlpha.Value), ref FavoriteTextColor))
			{
				ColorUtility.TryParseHtmlString("#F53548", ref FavoriteTextColor);
			}
			if (!ColorUtility.TryParseHtmlString(AppendTransparency(MysteryDice.DebugMenuAccentColor.Value, MysteryDice.DebugMenuAccentAlpha.Value), ref AccentColor))
			{
				ColorUtility.TryParseHtmlString("#A34EFF41", ref AccentColor);
			}
			if (!ColorUtility.TryParseHtmlString(AppendTransparency(MysteryDice.DebugMenuBackgroundColor.Value, MysteryDice.DebugMenuBackgroundAlpha.Value), ref BackgroundColor))
			{
				ColorUtility.TryParseHtmlString("#9B42FD76", ref BackgroundColor);
			}
		}

		public static void PrintHierarchy(Transform parent, string indent = "")
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			Debug.Log((object)(indent + ((Object)parent).name));
			foreach (Transform item in parent)
			{
				Transform parent2 = item;
				PrintHierarchy(parent2, indent + "  ");
			}
		}

		public static string AppendTransparency(string hexColor, int percentage)
		{
			string text = ((int)Math.Round((double)percentage / 100.0 * 255.0)).ToString("X2");
			return hexColor + text;
		}

		public static void setupElements()
		{
			buttonImages.Add(MysteryDice.DebugSubButtonPrefab.GetComponent<Image>());
			buttonImages.Add(MysteryDice.DebugMenuButtonPrefab.GetComponent<Image>());
			textElements.Add(MysteryDice.DebugSubButtonPrefab.GetComponentInChildren<TMP_Text>());
			textElements.Add(MysteryDice.DebugMenuButtonPrefab.GetComponentInChildren<TMP_Text>());
			buttonImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background/Scroll View/Scrollbar Vertical")).GetComponent<Image>());
			buttonImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background/ClearButton")).GetComponent<Image>());
			backgroundImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/TopPart")).GetComponent<Image>());
			backgroundImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background/Image")).GetComponent<Image>());
			backgroundImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background")).GetComponent<Image>());
			accentImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background/Border")).GetComponent<Image>());
			accentImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background/Scroll View")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/TopPart/Border/Title")).GetComponent<TMP_Text>());
			accentImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/TopPart/Border")).GetComponent<Image>());
			buttonImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Select Effect")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Select Effect/Text (TMP)")).GetComponent<TMP_Text>());
			textElements.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background/ClearButton/Text (TMP)")).GetComponent<TMP_Text>());
			buttonImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Spawn Menu")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Spawn Menu/Text (TMP)")).GetComponent<TMP_Text>());
			buttonImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Player Functions")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Player Functions/Text (TMP)")).GetComponent<TMP_Text>());
			buttonImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Special Functions")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Special Functions/Text (TMP)")).GetComponent<TMP_Text>());
			buttonImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Grant Admin")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Grant Admin/Text (TMP)")).GetComponent<TMP_Text>());
			accentImages.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Scroll View")).GetComponent<Image>());
			textElements2.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Toggle/Label")).GetComponent<Text>());
			textElements2.Add(((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Bald/Label")).GetComponent<Text>());
			setupSelectElements();
			ran = true;
		}

		public static void setupSelectElements()
		{
			buttonImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background/Scroll View/Scrollbar Vertical")).GetComponent<Image>());
			buttonImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background/ClearButton")).GetComponent<Image>());
			backgroundImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/TopPart")).GetComponent<Image>());
			backgroundImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background/Image")).GetComponent<Image>());
			backgroundImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background")).GetComponent<Image>());
			accentImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background/Border")).GetComponent<Image>());
			accentImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background/Scroll View")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/TopPart/Border/Title")).GetComponent<TMP_Text>());
			accentImages.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/TopPart/Border")).GetComponent<Image>());
			textElements.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background/ClearButton/Text (TMP)")).GetComponent<TMP_Text>());
			textElements2.Add(((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Bald/Label")).GetComponent<Text>());
		}

		public static void setColors()
		{
			//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_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_0041: 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_0068: 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_0082: 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_009c: 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_0100: 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_0182: 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)
			ColorBlock colors = ((Selectable)((Component)MysteryDice.DebugMenuPrefab.transform.Find("DebugMenu/Background/Scroll View/Scrollbar Vertical")).GetComponent<Scrollbar>()).colors;
			ColorBlock colors2 = ((Selectable)((Component)MysteryDice.NewSelectMenuPrefab.transform.Find("DebugMenu/Background/Scroll View/Scrollbar Vertical")).GetComponent<Scrollbar>()).colors;
			((ColorBlock)(ref colors)).normalColor = TextColor;
			((ColorBlock)(ref colors)).highlightedColor = TextColor;
			((ColorBlock)(ref colors)).pressedColor = TextColor;
			((ColorBlock)(ref colors)).selectedColor = TextColor;
			((ColorBlock)(ref colors2)).normalColor = TextColor;
			((ColorBlock)(ref colors2)).highlightedColor = TextColor;
			((ColorBlock)(ref colors2)).pressedColor = TextColor;
			((ColorBlock)(ref colors2)).selectedColor = TextColor;
			foreach (Image buttonImage in buttonImages)
			{
				((Graphic)buttonImage).color = ButtonColor;
			}
			foreach (TMP_Text textElement in textElements)
			{
				((Graphic)textElement).color = TextColor;
			}
			foreach (Text item in textElements2)
			{
				((Graphic)item).color = TextColor;
			}
			foreach (Image accentImage in accentImages)
			{
				((Graphic)accentImage).color = AccentColor;
			}
			foreach (Image backgroundImage in backgroundImages)
			{
				((Graphic)backgroundImage).color = BackgroundColor;
			}
		}

		private void CreateButton(bool sub, Transform parent, string label, UnityAction onClick)
		{
			GameObject val = ((!sub) ? Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, parent) : Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, parent));
			TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
			component.text = label;
			Button component2 = val.GetComponent<Button>();
			((UnityEvent)component2.onClick).AddListener(onClick);
		}

		public static void showDebugMenu(bool fulls, bool completes, bool sus = false)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//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_019d: Expected O, but got Unknown
			//IL_0658: Unknown result type (might be due to invalid IL or missing references)
			//IL_065d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Expected O, but got Unknown
			//IL_06ba: 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_06c5: Expected O, but got Unknown
			//IL_071c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0721: Unknown result type (might be due to invalid IL or missing references)
			//IL_0727: Expected O, but got Unknown
			//IL_077e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0783: Unknown result type (might be due to invalid IL or missing references)
			//IL_0789: Expected O, but got Unknown
			//IL_07c5: 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_07d0: Expected O, but got Unknown
			//IL_0847: 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_0852: Expected O, but got Unknown
			SetupColors();
			if (!ran)
			{
				setupElements();
			}
			if (ran)
			{
				setColors();
			}
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			DebugMenuStuff.OnDebugMenuOpen?.Invoke();
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.DebugMenuPrefab);
			if (MysteryDice.LockDebugUI.Value)
			{
				StartOfRound.Instance.localPlayerController.quickMenuManager.isMenuOpen = true;
			}
			subScrollContent = EffectMenu.transform.Find("DebugMenu/Scroll View/Viewport/Content");
			mainScrollContent = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			InputAction val = new InputAction((string)null, (InputActionType)0, "<Keyboard>/escape", (string)null, (string)null, (string)null);
			val.performed += delegate
			{
				CloseSelectMenu();
			};
			val.Enable();
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			searchInput = ((Component)EffectMenu.transform.Find("DebugMenu/Background/SearchField")).GetComponent<TMP_InputField>();
			((UnityEvent<string>)(object)searchInput.onValueChanged).AddListener((UnityAction<string>)FilterItems);
			Button component = ((Component)EffectMenu.transform.Find("DebugMenu/Background/ClearButton")).GetComponent<Button>();
			ButtonClickedEvent onClick = component.onClick;
			object obj = <>c.<>9__42_1;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					searchInput.text = "";
				};
				<>c.<>9__42_1 = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			full = fulls;
			complete = completes;
			su = sus;
			if (!SelectEffect.isSpecial() && !MysteryDice.superDebugMode.Value && !((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				full = false;
				complete = false;
				su = false;
			}
			if ((Object)(object)EffectMenu == (Object)null)
			{
				Debug.LogError((object)"EffectMenu is null after instantiation!");
				return;
			}
			DebugMenuController debugMenuController = EffectMenu.AddComponent<DebugMenuController>();
			debugMenuController.EffectMenu = EffectMenu;
			fromRandom = (fromMe = (fromYippee = false));
			((Component)EffectMenu.transform.Find("DebugMenu/Me")).gameObject.SetActive(false);
			((Component)EffectMenu.transform.Find("DebugMenu/Yippee")).gameObject.SetActive(false);
			((Component)EffectMenu.transform.Find("DebugMenu/Random")).gameObject.SetActive(false);
			((Component)EffectMenu.transform.Find("DebugMenu/GiveDice")).gameObject.SetActive(false);
			if (StartOfRound.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID)
			{
				((Component)EffectMenu.transform.Find("DebugMenu/Me")).gameObject.SetActive(true);
				((Component)EffectMenu.transform.Find("DebugMenu/Yippee")).gameObject.SetActive(true);
				((Component)EffectMenu.transform.Find("DebugMenu/Random")).gameObject.SetActive(true);
				Toggle component2 = ((Component)EffectMenu.transform.Find("DebugMenu/Me")).GetComponent<Toggle>();
				Toggle component3 = ((Component)EffectMenu.transform.Find("DebugMenu/Yippee")).GetComponent<Toggle>();
				Toggle component4 = ((Component)EffectMenu.transform.Find("DebugMenu/Random")).GetComponent<Toggle>();
				fromRandom = component4.isOn;
				fromMe = component2.isOn;
				fromYippee = component3.isOn;
				((UnityEvent<bool>)(object)component2.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					fromMe = isOn;
					if (isOn)
					{
						fromYippee = (fromRandom = false);
					}
				});
				((UnityEvent<bool>)(object)component3.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					fromYippee = isOn;
					if (isOn)
					{
						fromMe = (fromRandom = false);
					}
				});
				((UnityEvent<bool>)(object)component4.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					fromRandom = isOn;
					if (isOn)
					{
						fromMe = (fromYippee = false);
					}
				});
			}
			if (SelectEffect.isSpecial() || ((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost)
			{
				((Component)EffectMenu.transform.Find("DebugMenu/GiveDice")).gameObject.SetActive(true);
				Toggle component5 = ((Component)EffectMenu.transform.Find("DebugMenu/GiveDice")).GetComponent<Toggle>();
				diveGive = component5.isOn;
				((UnityEvent<bool>)(object)component5.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					diveGive = isOn;
				});
			}
			Toggle component6 = ((Component)EffectMenu.transform.Find("DebugMenu/Bald")).GetComponent<Toggle>();
			component6.isOn = MysteryDice.Bald.Value;
			GameObject BaldImage = ((Component)EffectMenu.transform.Find("DebugMenu/Background/Image")).gameObject;
			((UnityEvent<bool>)(object)component6.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
			{
				MysteryDice.Bald.Value = isOn;
				BaldImage.SetActive(isOn);
			});
			if (MysteryDice.Bald.Value)
			{
				BaldImage.SetActive(true);
			}
			else
			{
				BaldImage.SetActive(false);
			}
			Toggle component7 = ((Component)EffectMenu.transform.Find("DebugMenu/Toggle")).GetComponent<Toggle>();
			component7.isOn = !MysteryDice.DebugMenuClosesAfter.Value;
			((UnityEvent<bool>)(object)component7.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
			{
				MysteryDice.DebugMenuClosesAfter.Value = !isOn;
			});
			Toggle component8 = ((Component)EffectMenu.transform.Find("DebugMenu/Move")).GetComponent<Toggle>();
			component8.isOn = !MysteryDice.LockDebugUI.Value;
			((UnityEvent<bool>)(object)component8.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
			{
				MysteryDice.LockDebugUI.Value = !isOn;
				StartOfRound.Instance.localPlayerController.quickMenuManager.isMenuOpen = MysteryDice.LockDebugUI.Value;
			});
			Button component9 = ((Component)EffectMenu.transform.Find("DebugMenu/CloseButton")).GetComponent<Button>();
			ButtonClickedEvent onClick2 = component9.onClick;
			object obj2 = <>c.<>9__42_5;
			if (obj2 == null)
			{
				UnityAction val3 = delegate
				{
					CloseSelectMenu(force: true);
				};
				<>c.<>9__42_5 = val3;
				obj2 = (object)val3;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			Button component10 = ((Component)EffectMenu.transform.Find("DebugMenu/Select Effect")).GetComponent<Button>();
			TMP_Text component11 = ((Component)EffectMenu.transform.Find("DebugMenu/Select Effect/Text (TMP)")).GetComponent<TMP_Text>();
			ButtonClickedEvent onClick3 = component10.onClick;
			object obj3 = <>c.<>9__42_6;
			if (obj3 == null)
			{
				UnityAction val4 = delegate
				{
					clearMainViewport();
					ShowSelectMenu();
					FilterItems(searchInput.text);
				};
				<>c.<>9__42_6 = val4;
				obj3 = (object)val4;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			Button component12 = ((Component)EffectMenu.transform.Find("DebugMenu/Spawn Menu")).GetComponent<Button>();
			TMP_Text component13 = ((Component)EffectMenu.transform.Find("DebugMenu/Spawn Menu/Text (TMP)")).GetComponent<TMP_Text>();
			ButtonClickedEvent onClick4 = component12.onClick;
			object obj4 = <>c.<>9__42_7;
			if (obj4 == null)
			{
				UnityAction val5 = delegate
				{
					clearSubViewport();
					spawnFunctions();
					FilterItems(searchInput.text);
				};
				<>c.<>9__42_7 = val5;
				obj4 = (object)val5;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			Button component14 = ((Component)EffectMenu.transform.Find("DebugMenu/Player Functions")).GetComponent<Button>();
			TMP_Text component15 = ((Component)EffectMenu.transform.Find("DebugMenu/Player Functions/Text (TMP)")).GetComponent<TMP_Text>();
			ButtonClickedEvent onClick5 = component14.onClick;
			object obj5 = <>c.<>9__42_8;
			if (obj5 == null)
			{
				UnityAction val6 = delegate
				{
					clearSubViewport();
					playerFunctions();
					FilterItems(searchInput.text);
				};
				<>c.<>9__42_8 = val6;
				obj5 = (object)val6;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			Button component16 = ((Component)EffectMenu.transform.Find("DebugMenu/Special Functions")).GetComponent<Button>();
			ButtonClickedEvent onClick6 = component16.onClick;
			object obj6 = <>c.<>9__42_9;
			if (obj6 == null)
			{
				UnityAction val7 = delegate
				{
					clearSubViewport();
					specialFunctions(SelectEffect.isSpecial());
					FilterItems(searchInput.text);
				};
				<>c.<>9__42_9 = val7;
				obj6 = (object)val7;
			}
			((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			Button component17 = ((Component)EffectMenu.transform.Find("DebugMenu/Grant Admin")).GetComponent<Button>();
			if (su || ((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost)
			{
				TMP_Text component18 = ((Component)EffectMenu.transform.Find("DebugMenu/Grant Admin/Text (TMP)")).GetComponent<TMP_Text>();
				ButtonClickedEvent onClick7 = component17.onClick;
				object obj7 = <>c.<>9__42_14;
				if (obj7 == null)
				{
					UnityAction val8 = delegate
					{
						clearSubViewport();
						AdminFunctions();
						FilterItems(searchInput.text);
					};
					<>c.<>9__42_14 = val8;
					obj7 = (object)val8;
				}
				((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)component17).gameObject);
			}
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
		}

		public static void ShowSelectEffectMenu(bool isAdMenu = false)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//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_027d: Expected O, but got Unknown
			SetupColors();
			if (!ran)
			{
				setupElements();
			}
			if (ran)
			{
				setColors();
			}
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			full = false;
			complete = false;
			su = false;
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			if (MysteryDice.LockDebugUI.Value)
			{
				StartOfRound.Instance.localPlayerController.quickMenuManager.isMenuOpen = true;
			}
			mainScrollContent = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			InputAction val = new InputAction((string)null, (InputActionType)0, "<Keyboard>/escape", (string)null, (string)null, (string)null);
			val.performed += delegate
			{
				CloseSelectMenu();
			};
			val.Enable();
			TMP_InputField searchInput = ((Component)EffectMenu.transform.Find("DebugMenu/Background/SearchField")).GetComponent<TMP_InputField>();
			((UnityEvent<string>)(object)searchInput.onValueChanged).AddListener((UnityAction<string>)FilterItems);
			Button component = ((Component)EffectMenu.transform.Find("DebugMenu/Background/ClearButton")).GetComponent<Button>();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				searchInput.text = "";
			});
			if ((Object)(object)EffectMenu == (Object)null)
			{
				Debug.LogError((object)"EffectMenu is null after instantiation!");
				return;
			}
			DebugMenuController debugMenuController = EffectMenu.AddComponent<DebugMenuController>();
			debugMenuController.EffectMenu = EffectMenu;
			Toggle component2 = ((Component)EffectMenu.transform.Find("DebugMenu/Bald")).GetComponent<Toggle>();
			component2.isOn = MysteryDice.Bald.Value;
			GameObject BaldImage = ((Component)EffectMenu.transform.Find("DebugMenu/Background/Image")).gameObject;
			((UnityEvent<bool>)(object)component2.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
			{
				MysteryDice.Bald.Value = isOn;
				BaldImage.SetActive(isOn);
			});
			if (MysteryDice.Bald.Value)
			{
				BaldImage.SetActive(true);
			}
			else
			{
				BaldImage.SetActive(false);
			}
			Button component3 = ((Component)EffectMenu.transform.Find("DebugMenu/CloseButton")).GetComponent<Button>();
			ButtonClickedEvent onClick = component3.onClick;
			object obj = <>c.<>9__43_3;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					CloseSelectMenu(force: true);
				};
				<>c.<>9__43_3 = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			if (!isAdMenu)
			{
				ShowSelectMenu(fromSaint: true);
				return;
			}
			((Component)EffectMenu.transform.Find("DebugMenu/TopPart/Border/Title")).GetComponent<TMP_Text>().text = "Select an Ad";
			((Component)EffectMenu.transform.Find("DebugMenu/Background/TopText")).gameObject.SetActive(true);
			((Component)EffectMenu.transform.Find("DebugMenu/Background/BottomText")).gameObject.SetActive(true);
			AdUnlockable(fromSelect: true);
			AdAnyItem(fromSelect: true);
		}

		private static void FilterItems(string searchText)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			foreach (Transform item in val)
			{
				Transform val2 = item;
				TextMeshProUGUI componentInChildren = ((Component)val2).GetComponentInChildren<TextMeshProUGUI>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					bool active = string.IsNullOrEmpty(searchText) || ((TMP_Text)componentInChildren).text.ToLower().Contains(searchText.ToLower());
					((Component)val2).gameObject.SetActive(active);
				}
			}
		}

		public static void clearMainViewport()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			hideStuff();
			foreach (Transform item in val)
			{
				Transform val2 = item;
				Object.Destroy((Object)(object)((Component)val2).gameObject);
			}
		}

		public static void hideStuff()
		{
			((Component)EffectMenu.transform.Find("DebugMenu/Background/TopText")).gameObject.SetActive(false);
			((Component)EffectMenu.transform.Find("DebugMenu/Background/BottomText")).gameObject.SetActive(false);
			((Component)EffectMenu.transform.Find("DebugMenu/Background/SizeModifiers")).gameObject.SetActive(false);
		}

		public static void clearSubViewport()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Scroll View/Viewport/Content");
			foreach (Transform item in val)
			{
				Transform val2 = item;
				Object.Destroy((Object)(object)((Component)val2).gameObject);
			}
		}

		public static List<IEffect> getOrdered()
		{
			List<IEffect> list = new List<IEffect>(complete ? DieBehaviour.CompleteEffects : (full ? DieBehaviour.AllEffects : DieBehaviour.AllowedEffects));
			if (StartOfRound.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID || StartOfRound.Instance.localPlayerController.playerSteamId == 76561199094139351L || StartOfRound.Instance.localPlayerController.playerSteamId == 76561198984467725L)
			{
				list.Add(new ForceTakeoff());
			}
			if (StartOfRound.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID)
			{
				list.Add(new ForceUpdateScannodes());
			}
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteEffectNames = favoriteData.Favorites;
			return list.OrderByDescending((IEffect effect) => favoriteEffectNames.Contains(effect.Name)).ThenBy<IEffect, string>((IEffect effect) => effect.Name, StringComparer.OrdinalIgnoreCase).ToList();
		}

		public static void spawnEnemy()
		{
			//IL_0141: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteEnemyNames = favoriteData.FavoriteEnemies;
			List<EnemyType> list = (from x in GetEnemies.allEnemies
				group x by x.enemyName into g
				select g.First() into e
				orderby (!favoriteEnemyNames.Contains(e.enemyName)) ? 1 : 0, e.enemyName
				select e).ToList();
			foreach (EnemyType enemy in list)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteEnemyNames.Contains(enemy.enemyName);
				string text = (flag ? "*" : "");
				component.text = text + " " + enemy.enemyName;
				((Graphic)component).color = (flag ? FavoriteTextColor : TextColor);
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_003b: 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_0049: 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_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)
					CloseSelectMenu();
					if (StartOfRound.Instance.localPlayerController.isPlayerDead)
					{
						Networker.Instance.SpawnEnemyAtPosServerRPC(enemy.enemyName, ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					}
					else if (MysteryDice.debugSpawnOnPlayer.Value)
					{
						Networker.Instance.SpawnEnemyAtPosServerRPC(enemy.enemyName, ((Component)StartOfRound.Instance.localPlayerController).transform.position);
					}
					else
					{
						Networker.Instance.CustomMonsterServerRPC(enemy.enemyName, 1, 1, StartOfRound.Instance.localPlayerController.isInsideFactory);
					}
					string text2 = (StartOfRound.Instance.localPlayerController.isInsideFactory ? "Inside" : "Outside");
					string body = "Spawned " + enemy.enemyName + " " + text2;
					Misc.SafeTipMessage("Spawned " + enemy.enemyName, body);
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = enemy.enemyName;
				rightClickHandler.category = "FavoriteEnemies";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnMiniEnemy()
		{
			//IL_017b: 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_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteEnemyNames = favoriteData.FavoriteEnemies;
			((Component)EffectMenu.transform.Find("DebugMenu/Background/SizeModifiers")).gameObject.SetActive(true);
			List<EnemyType> list = (from x in GetEnemies.allEnemies
				group x by x.enemyName into g
				select g.First() into e
				orderby (!favoriteEnemyNames.Contains(e.enemyName)) ? 1 : 0, e.enemyName
				select e).ToList();
			foreach (EnemyType enemy in list)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteEnemyNames.Contains(enemy.enemyName);
				string text = (flag ? "*" : "");
				component.text = text + " " + enemy.enemyName;
				((Graphic)component).color = (flag ? Color.red : TextColor);
				GameObject sizeMod = ((Component)EffectMenu.transform.Find("DebugMenu/Background/SizeModifiers")).gameObject;
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//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_00b1: 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)
					CloseSelectMenu();
					float num = float.Parse(((Component)sizeMod.transform.Find("X")).GetComponent<TMP_InputField>().text);
					float num2 = float.Parse(((Component)sizeMod.transform.Find("Y")).GetComponent<TMP_InputField>().text);
					float num3 = float.Parse(((Component)sizeMod.transform.Find("Z")).GetComponent<TMP_InputField>().text);
					if (StartOfRound.Instance.localPlayerController.isPlayerDead)
					{
						Networker.Instance.SpawnEnemyAtPosServerRPC(enemy.enemyName, ((Component)StartOfRound.Instance.spectateCamera).transform.position, useSize: true, new Vector3(num, num2, num3));
					}
					else
					{
						Networker.Instance.SpawnEnemyAtPosServerRPC(enemy.enemyName, ((Component)StartOfRound.Instance.localPlayerController).transform.position, useSize: true, new Vector3(num, num2, num3));
					}
					string text2 = (StartOfRound.Instance.localPlayerController.isInsideFactory ? "Inside" : "Outside");
					string body = "Spawned " + enemy.enemyName + " " + text2;
					Misc.SafeTipMessage("Spawned " + enemy.enemyName, body);
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = enemy.enemyName;
				rightClickHandler.category = "FavoriteEnemies";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnFreebirdEnemy()
		{
			//IL_0141: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteEnemyNames = favoriteData.FavoriteEnemies;
			List<EnemyType> list = (from x in GetEnemies.allEnemies
				group x by x.enemyName into g
				select g.First() into e
				orderby (!favoriteEnemyNames.Contains(e.enemyName)) ? 1 : 0, e.enemyName
				select e).ToList();
			foreach (EnemyType enemy in list)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteEnemyNames.Contains(enemy.enemyName);
				string text = (flag ? "*" : "");
				component.text = text + " " + enemy.enemyName;
				((Graphic)component).color = (flag ? Color.red : TextColor);
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//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_003d: 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_00af: Unknown result type (might be due to invalid IL or missing references)
					CloseSelectMenu();
					if (StartOfRound.Instance.localPlayerController.isPlayerDead)
					{
						Networker.Instance.SpawnFreebirdEnemyServerRPC(enemy.enemyName, outside: true, usePos: true, ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					}
					else
					{
						RoundManager instance = RoundManager.Instance;
						Vector3 pos = Vector3.zero;
						bool usePos = false;
						if (MysteryDice.debugSpawnOnPlayer.Value)
						{
							usePos = true;
							pos = ((Component)StartOfRound.Instance.localPlayerController).transform.position;
						}
						Networker.Instance.SpawnFreebirdEnemyServerRPC(enemy.enemyName, enemy.isDaytimeEnemy || enemy.isOutsideEnemy, usePos, pos);
					}
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = enemy.enemyName;
				rightClickHandler.category = "FavoriteEnemies";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnFreebirdTrap()
		{
			//IL_0148: 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_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteTrapNames = favoriteData.FavoriteTraps;
			List<trap> source = (from x in Misc.getAllTraps()
				group x by x.name into g
				select g.First()).ToList();
			source = (from t in source
				orderby (!favoriteTrapNames.Contains(t.name)) ? 1 : 0, t.name
				select t).ToList();
			foreach (trap trap in source)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteTrapNames.Contains(trap.name);
				string text = (flag ? "*" : "");
				component.text = text + " " + trap.name;
				((Graphic)component).color = (flag ? Color.red : TextColor);
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					Networker.Instance.SpawnFreebirdTrapServerRPC(trap.name);
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = trap.name;
				rightClickHandler.category = "FavoriteTraps";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnTrap()
		{
			//IL_0148: 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_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteTrapNames = favoriteData.FavoriteTraps;
			List<trap> source = (from x in Misc.getAllTraps()
				group x by x.name into g
				select g.First()).ToList();
			source = (from t in source
				orderby (!favoriteTrapNames.Contains(t.name)) ? 1 : 0, t.name
				select t).ToList();
			foreach (trap trap in source)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteTrapNames.Contains(trap.name);
				string text = (flag ? "*" : "");
				component.text = text + " " + trap.name;
				((Graphic)component).color = (flag ? FavoriteTextColor : TextColor);
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//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_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_00a2: 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)
					CloseSelectMenu();
					Vector3 val2 = ((!StartOfRound.Instance.localPlayerController.isPlayerDead) ? ((Component)StartOfRound.Instance.localPlayerController).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					Networker.Instance.spawnTrapOnServerRPC(trap.name, 1, StartOfRound.Instance.localPlayerController.isInsideFactory, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), StartOfRound.Instance.localPlayerController.isPlayerDead || StartOfRound.Instance.inShipPhase, val2);
					Misc.SafeTipMessage("Spawned " + trap.name, $"Spawned at {val2}");
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = trap.name;
				rightClickHandler.category = "FavoriteTraps";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnScrap()
		{
			//IL_017b: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteScrapNames = favoriteData.FavoriteScraps;
			List<SpawnableItemWithRarity> source = (from x in StartOfRound.Instance.levels.SelectMany((SelectableLevel level) => level.spawnableScrap)
				group x by x.spawnableItem.itemName into g
				select g.First()).ToList();
			source = (from s in source
				orderby (!favoriteScrapNames.Contains(s.spawnableItem.itemName)) ? 1 : 0, s.spawnableItem.itemName
				select s).ToList();
			foreach (SpawnableItemWithRarity scrap in source)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteScrapNames.Contains(scrap.spawnableItem.itemName);
				string text = (flag ? "*" : "");
				component.text = text + " " + scrap.spawnableItem.itemName;
				((Graphic)component).color = (flag ? FavoriteTextColor : TextColor);
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//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_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_0089: 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)
					CloseSelectMenu();
					Vector3 val2 = ((!StartOfRound.Instance.localPlayerController.isPlayerDead) ? ((Component)StartOfRound.Instance.localPlayerController).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, scrap.spawnableItem.itemName, StartOfRound.Instance.localPlayerController.isPlayerDead, val2);
					Misc.SafeTipMessage("Spawned " + ((Object)scrap.spawnableItem).name, $"Spawned at {val2}");
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = scrap.spawnableItem.itemName;
				rightClickHandler.category = "FavoriteScraps";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnAnyItem()
		{
			//IL_018a: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteItemsNames = favoriteData.FavoriteItems;
			List<Item> list = (from s in StartOfRound.Instance.allItemsList.itemsList.ToList()
				orderby (!favoriteItemsNames.Contains(s.itemName)) ? 1 : 0, s.itemName
				select s).ToList();
			PlayerControllerB localPlayer = StartOfRound.Instance.localPlayerController;
			foreach (Item scrap in list)
			{
				GameObject prefab = scrap.spawnPrefab;
				int prefabIndex = NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs.FindIndex((NetworkPrefab p) => (Object)(object)p.Prefab == (Object)(object)prefab);
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteItemsNames.Contains(scrap.itemName);
				string text = (flag ? "*" : "");
				component.text = text + " " + scrap.itemName;
				((Graphic)component).color = (flag ? FavoriteTextColor : TextColor);
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//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_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_00b1: 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)
					CloseSelectMenu();
					Vector3 val2 = ((!localPlayer.isPlayerDead) ? ((Component)localPlayer).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					int amount = ((!((ButtonControl)Keyboard.current.leftShiftKey).isPressed) ? 1 : 5);
					Networker.Instance.SameScrapAdvancedServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), amount, scrap.itemName, localPlayer.isPlayerDead, val2, prefabIndex);
					Misc.SafeTipMessage("Spawned " + ((Object)scrap).name, $"Spawned at {val2}");
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = scrap.itemName;
				rightClickHandler.category = "FavoriteItems";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void AdAnyItem(bool fromSelect = false)
		{
			//IL_011d: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteItemsNames = favoriteData.FavoriteItems;
			List<Item> list = (from s in StartOfRound.Instance.allItemsList.itemsList.ToList()
				orderby (!favoriteItemsNames.Contains(s.itemName)) ? 1 : 0, s.itemName
				select s).ToList();
			foreach (Item scrap in list)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteItemsNames.Contains(scrap.itemName);
				string text = (flag ? "*" : "");
				component.text = text + " " + scrap.itemName;
				((Graphic)component).color = (flag ? FavoriteTextColor : TextColor);
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu(fromSelect);
					Networker.Instance.AdServerRPC(item: true, scrap.itemName, getTopText(), getBottomText());
				});
				RightClickHandler2 rightClickHandler = val.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = scrap.itemName;
				rightClickHandler.category = "FavoriteAdItems";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static string getTopText()
		{
			string result = ManyAds.getTopText();
			TMP_InputField component = ((Component)EffectMenu.transform.Find("DebugMenu/Background/TopText")).GetComponent<TMP_InputField>();
			if (component.text != "")
			{
				result = component.text;
			}
			return result;
		}

		public static string getBottomText()
		{
			string result = ManyAds.getBottomText();
			TMP_InputField component = ((Component)EffectMenu.transform.Find("DebugMenu/Background/BottomText")).GetComponent<TMP_InputField>();
			if (component.text != "")
			{
				result = component.text;
			}
			return result;
		}

		public static void AdUnlockable(bool fromSelect = false)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			foreach (UnlockableItem item in StartOfRound.Instance.unlockablesList.unlockables)
			{
				if (!((Object)(object)item.prefabObject == (Object)null))
				{
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
					TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = item.unlockableName;
					Button component2 = val2.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						Networker.Instance.AdServerRPC(item: false, item.unlockableName, getTopText(), getBottomText());
						CloseSelectMenu(fromSelect);
					});
				}
			}
		}

		public static void spawnWorldObject()
		{
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			List<SpawnableOutsideObject> list = new List<SpawnableOutsideObject>();
			list = GetEnemies.allObjects.ToList();
			list = (from x in list
				group x by ((Object)x).name into g
				select g.First() into x
				orderby ((Object)x).name
				select x).ToList();
			foreach (SpawnableOutsideObject scrap in list)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = ((Object)scrap).name ?? "";
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					Networker.Instance.SpawnObjectServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, ((Object)scrap).name);
					string text = "";
					text = "Spawned " + ((Object)scrap).name;
					Misc.SafeTipMessage("Object Spawned", text);
				});
			}
		}

		public static void spawnShopItems()
		{
			//IL_0150: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteShopItemNames = favoriteData.FavoriteShopItems;
			Terminal val = Object.FindObjectOfType<Terminal>();
			List<Item> source = (from x in val.buyableItemsList
				group x by x.itemName into g
				select g.First()).ToList();
			source = (from s in source
				orderby (!favoriteShopItemNames.Contains(s.itemName)) ? 1 : 0, s.itemName
				select s).ToList();
			foreach (Item item in source)
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteShopItemNames.Contains(item.itemName);
				string text = (flag ? "*" : "");
				component.text = text + " " + item.itemName;
				((Graphic)component).color = (flag ? FavoriteTextColor : TextColor);
				Button component2 = val2.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//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_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_0074: Unknown result type (might be due to invalid IL or missing references)
					CloseSelectMenu();
					Vector3 position = ((!StartOfRound.Instance.localPlayerController.isPlayerDead) ? ((Component)StartOfRound.Instance.localPlayerController).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					Networker.Instance.spawnStoreItemServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), item.itemName, position);
				});
				RightClickHandler2 rightClickHandler = val2.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = item.itemName;
				rightClickHandler.category = "FavoriteShopItems";
			}
		}

		public static void grantAdmin(bool grant)
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (Misc.IsPlayerReal(player))
				{
					GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
					TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = player.playerUsername ?? "";
					Button component2 = val.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						CloseSelectMenu();
						Networker.Instance.becomeAdminServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), grant);
						string text = "";
						text = "Made " + player.playerUsername + " an admin";
					});
				}
			}
		}

		public static void killPlayer()
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (Misc.IsPlayerAliveAndControlled(player))
				{
					GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
					TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = player.playerUsername ?? "";
					Button component2 = val.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						CloseSelectMenu();
						Networker.Instance.killPlayerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player));
					});
				}
			}
		}

		public static void fixPlayer()
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (Misc.IsPlayerAliveAndControlled(player))
				{
					GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
					TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = player.playerUsername ?? "";
					Button component2 = val.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						CloseSelectMenu();
						Networker.Instance.FixPlayerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player));
					});
				}
			}
		}

		public static void spawnFunctions()
		{
			//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_005b: Expected O, but got Unknown
			//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_00bf: Expected O, but got Unknown
			//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_0126: Expected O, but got Unknown
			//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_01b0: Expected O, but got Unknown
			//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_0217: Expected O, but got Unknown
			//IL_02b1: 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_02bc: Expected O, but got Unknown
			//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_0323: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
			component.text = "Spawn Enemy";
			Button component2 = val.GetComponent<Button>();
			ButtonClickedEvent onClick = component2.onClick;
			object obj = <>c.<>9__65_0;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					clearMainViewport();
					spawnEnemy();
					FilterItems(searchInput.text);
				};
				<>c.<>9__65_0 = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component3 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
			component3.text = "Spawn Items (any)";
			Button component4 = val3.GetComponent<Button>();
			ButtonClickedEvent onClick2 = component4.onClick;
			object obj2 = <>c.<>9__65_1;
			if (obj2 == null)
			{
				UnityAction val4 = delegate
				{
					clearMainViewport();
					spawnAnyItem();
					FilterItems(searchInput.text);
				};
				<>c.<>9__65_1 = val4;
				obj2 = (object)val4;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			GameObject val5 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component5 = ((Component)val5.transform.GetChild(0)).GetComponent<TMP_Text>();
			component5.text = "Spawn Trap";
			Button component6 = val5.GetComponent<Button>();
			ButtonClickedEvent onClick3 = component6.onClick;
			object obj3 = <>c.<>9__65_2;
			if (obj3 == null)
			{
				UnityAction val6 = delegate
				{
					clearMainViewport();
					spawnTrap();
					FilterItems(searchInput.text);
				};
				<>c.<>9__65_2 = val6;
				obj3 = (object)val6;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			if (SelectEffect.isSpecial() || ((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost)
			{
				GameObject val7 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
				TMP_Text component7 = ((Component)val7.transform.GetChild(0)).GetComponent<TMP_Text>();
				component7.text = "Spawn Outside Objects";
				Button component8 = val7.GetComponent<Button>();
				ButtonClickedEvent onClick4 = component8.onClick;
				object obj4 = <>c.<>9__65_3;
				if (obj4 == null)
				{
					UnityAction val8 = delegate
					{
						clearMainViewport();
						spawnWorldObject();
						FilterItems(searchInput.text);
					};
					<>c.<>9__65_3 = val8;
					obj4 = (object)val8;
				}
				((UnityEvent)onClick4).AddListener((UnityAction)obj4);
				GameObject val9 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
				TMP_Text component9 = ((Component)val9.transform.GetChild(0)).GetComponent<TMP_Text>();
				component9.text = "Spawn Sized Enemy";
				Button component10 = val9.GetComponent<Button>();
				ButtonClickedEvent onClick5 = component10.onClick;
				object obj5 = <>c.<>9__65_4;
				if (obj5 == null)
				{
					UnityAction val10 = delegate
					{
						clearMainViewport();
						spawnMiniEnemy();
						FilterItems(searchInput.text);
					};
					<>c.<>9__65_4 = val10;
					obj5 = (object)val10;
				}
				((UnityEvent)onClick5).AddListener((UnityAction)obj5);
				if (StartOfRound.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID || ((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost || GameNetworkManager.Instance.disableSteam)
				{
					GameObject val11 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
					TMP_Text component11 = ((Component)val11.transform.GetChild(0)).GetComponent<TMP_Text>();
					component11.text = "Spawn Freebird Enemy";
					Button component12 = val11.GetComponent<Button>();
					ButtonClickedEvent onClick6 = component12.onClick;
					object obj6 = <>c.<>9__65_5;
					if (obj6 == null)
					{
						UnityAction val12 = delegate
						{
							clearMainViewport();
							spawnFreebirdEnemy();
							FilterItems(searchInput.text);
						};
						<>c.<>9__65_5 = val12;
						obj6 = (object)val12;
					}
					((UnityEvent)onClick6).AddListener((UnityAction)obj6);
					GameObject val13 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
					TMP_Text component13 = ((Component)val13.transform.GetChild(0)).GetComponent<TMP_Text>();
					component13.text = "Spawn Freebird Trap";
					Button component14 = val13.GetComponent<Button>();
					ButtonClickedEvent onClick7 = component14.onClick;
					object obj7 = <>c.<>9__65_6;
					if (obj7 == null)
					{
						UnityAction val14 = delegate
						{
							clearMainViewport();
							spawnFreebirdTrap();
							FilterItems(searchInput.text);
						};
						<>c.<>9__65_6 = val14;
						obj7 = (object)val14;
					}
					((UnityEvent)onClick7).AddListener((UnityAction)obj7);
				}
			}
			DebugMenuStuff.OnSpawnFunctionsAdded?.Invoke(subScrollContent);
		}

		public static void specialFunctions(bool special)
		{
			//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: 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_01b5: Expected O, but got Unknown
			//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_0154: Expected O, but got Unknown
			//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_00d4: Expected O, but got Unknown
			//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_0219: 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
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_0343: 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_034e: Expected O, but got Unknown
			if (special)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = "Play Sound";
				Button component2 = val.GetComponent<Button>();
				ButtonClickedEvent onClick = component2.onClick;
				object obj = <>c.<>9__66_5;
				if (obj == null)
				{
					UnityAction val2 = delegate
					{
						clearMainViewport();
						ShowSoundMenu();
						FilterItems(searchInput.text);
					};
					<>c.<>9__66_5 = val2;
					obj = (object)val2;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
				TMP_Text component3 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
				component3.text = "Jumpscare";
				Button component4 = val3.GetComponent<Button>();
				ButtonClickedEvent onClick2 = component4.onClick;
				object obj2 = <>c.<>9__66_6;
				if (obj2 == null)
				{
					UnityAction val4 = delegate
					{
						clearMainViewport();
						ShowJumpscareMenu();
						FilterItems(searchInput.text);
					};
					<>c.<>9__66_6 = val4;
					obj2 = (object)val4;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			}
			if (((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost || special)
			{
				GameObject val5 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
				TMP_Text component5 = ((Component)val5.transform.GetChild(0)).GetComponent<TMP_Text>();
				component5.text = "Unlock Unlockable";
				Button component6 = val5.GetComponent<Button>();
				ButtonClickedEvent onClick3 = component6.onClick;
				object obj3 = <>c.<>9__66_7;
				if (obj3 == null)
				{
					UnityAction val6 = delegate
					{
						clearMainViewport();
						UnlockSomething();
						FilterItems(searchInput.text);
					};
					<>c.<>9__66_7 = val6;
					obj3 = (object)val6;
				}
				((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			}
			GameObject val7 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component7 = ((Component)val7.transform.GetChild(0)).GetComponent<TMP_Text>();
			component7.text = "AdItem";
			Button component8 = val7.GetComponent<Button>();
			ButtonClickedEvent onClick4 = component8.onClick;
			object obj4 = <>c.<>9__66_0;
			if (obj4 == null)
			{
				UnityAction val8 = delegate
				{
					clearMainViewport();
					if (SelectEffect.isSpecial())
					{
						((Component)EffectMenu.transform.Find("DebugMenu/Background/TopText")).gameObject.SetActive(true);
						((Component)EffectMenu.transform.Find("DebugMenu/Background/BottomText")).gameObject.SetActive(true);
					}
					AdAnyItem();
					FilterItems(searchInput.text);
				};
				<>c.<>9__66_0 = val8;
				obj4 = (object)val8;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			GameObject val9 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component9 = ((Component)val9.transform.GetChild(0)).GetComponent<TMP_Text>();
			component9.text = "Ad Unlockable";
			Button component10 = val9.GetComponent<Button>();
			ButtonClickedEvent onClick5 = component10.onClick;
			object obj5 = <>c.<>9__66_1;
			if (obj5 == null)
			{
				UnityAction val10 = delegate
				{
					clearMainViewport();
					if (SelectEffect.isSpecial())
					{
						((Component)EffectMenu.transform.Find("DebugMenu/Background/TopText")).gameObject.SetActive(true);
						((Component)EffectMenu.transform.Find("DebugMenu/Background/BottomText")).gameObject.SetActive(true);
					}
					AdUnlockable();
					FilterItems(searchInput.text);
				};
				<>c.<>9__66_1 = val10;
				obj5 = (object)val10;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			GameObject val11 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component11 = ((Component)val11.transform.GetChild(0)).GetComponent<TMP_Text>();
			component11.text = "POI Teleports";
			Button component12 = val11.GetComponent<Button>();
			ButtonClickedEvent onClick6 = component12.onClick;
			object obj6 = <>c.<>9__66_2;
			if (obj6 == null)
			{
				UnityAction val12 = delegate
				{
					clearMainViewport();
					poiTeleports();
					FilterItems(searchInput.text);
				};
				<>c.<>9__66_2 = val12;
				obj6 = (object)val12;
			}
			((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			GameObject val13 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component13 = ((Component)val13.transform.GetChild(0)).GetComponent<TMP_Text>();
			component13.text = "Enemy Teleports";
			Button component14 = val13.GetComponent<Button>();
			ButtonClickedEvent onClick7 = component14.onClick;
			object obj7 = <>c.<>9__66_3;
			if (obj7 == null)
			{
				UnityAction val14 = delegate
				{
					clearMainViewport();
					enemyTeleports();
					FilterItems(searchInput.text);
				};
				<>c.<>9__66_3 = val14;
				obj7 = (object)val14;
			}
			((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			GameObject val15 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, subScrollContent);
			TMP_Text component15 = ((Component)val15.transform.GetChild(0)).GetComponent<TMP_Text>();
			component15.text = "Scrap Teleports";
			Button component16 = val15.GetComponent<Button>();
			ButtonClickedEvent onClick8 = component16.onClick;
			object obj8 = <>c.<>9__66_4;
			if (obj8 == null)
			{
				UnityAction val16 = delegate
				{
					clearMainViewport();
					scrapTeleports();
					FilterItems(searchInput.text);
				};
				<>c.<>9__66_4 = val16;
				obj8 = (object)val16;
			}
			((UnityEvent)onClick8).AddListener((UnityAction)obj8);
			DebugMenuStuff.OnSpecialFunctionsAdded?.Invoke(subScrollContent);
		}

		public static void poiTeleports()
		{
			//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_005b: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
			TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
			component.text = "Ship";
			Button component2 = val.GetComponent<Button>();
			ButtonClickedEvent onClick = component2.onClick;
			object obj = <>c.<>9__67_0;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					Networker.Instance.TeleportOrBringPlayerToPosServerRPC(StartOfRound.Instance.middleOfShipNode.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
					GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom = true;
					GameNetworkManager.Instance.localPlayerController.isInsideFactory = false;
					GameNetworkManager.Instance.localPlayerController.isInElevator = false;
					CloseSelectMenu();
				};
				<>c.<>9__67_0 = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			EntranceTeleport[] array = Object.FindObjectsByType<EntranceTeleport>((FindObjectsSortMode)0);
			EntranceTeleport[] array2 = array;
			foreach (EntranceTeleport entrance in array2)
			{
				GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component3 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
				component3.text = ((entrance.entranceId == 0) ? "Main" : "Fire Exit") + " " + (entrance.isEntranceToBuilding ? "Inside" : "Outside");
				Button component4 = val3.GetComponent<Button>();
				((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
				{
					entrance.TeleportPlayer();
					CloseSelectMenu();
				});
			}
		}

		public static void enemyTeleports()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			foreach (EnemyAI enemy in RoundManager.Instance.SpawnedEnemies)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = enemy.enemyType.enemyName;
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					Networker.Instance.TeleportOrBringPlayerToPosServerRPC(((Component)enemy).transform.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
					CloseSelectMenu();
					GameNetworkManager.Instance.localPlayerController.isInsideFactory = !enemy.isOutside;
				});
			}
		}

		public static void scrapTeleports()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			GrabbableObject[] array2 = array;
			foreach (GrabbableObject scrap in array2)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = ((Object)scrap).name;
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0011: 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)
					Networker.Instance.TeleportOrBringPlayerToPosServerRPC(((Component)scrap).transform.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
					CloseSelectMenu();
					GameNetworkManager.Instance.localPlayerController.isInsideFactory = !(((Component)scrap).transform.position.y < -1000f);
				});
			}
		}

		public static void scrapDeletes()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			GrabbableObject[] array2 = array;
			foreach (GrabbableObject scrap in array2)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = ((Object)scrap).name;
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)((NetworkBehaviour)scrap).NetworkObject == (Object)null))
					{
						Networker.Instance.DeleteThingServerRPC(NetworkObjectReference.op_Implicit(((NetworkBehaviour)scrap).NetworkObject));
					}
				});
			}
		}

		public static void enemyDeletes()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			foreach (EnemyAI enemy in RoundManager.Instance.SpawnedEnemies)
			{
				GameObject val = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, mainScrollContent);
				TMP_Text component = ((Component)val.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = enemy.enemyType.enemyName;
				Button component2 = val.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)((NetworkBehaviour)enemy).NetworkObject == (Object)null))
					{
						Networker.Instance.DeleteThingServerRPC(NetworkObjectReference.op_Implicit(((NetworkBehaviour)enemy).NetworkObject));
						CloseSelectMenu();
					}
				});
			}
		}

		public static void AdminFunctions()
		{
			//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_006c: 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_00cf: Expected O, but got Unknown
			//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: Expected O, but got Unknown
			//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_0195: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Scroll View/Viewport/Content");
			GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
			component.text = "Grant Admin Usage";
			Button component2 = val2.GetComponent<Button>();
			ButtonClickedEvent onClick = component2.onClick;
			object obj = <>c.<>9__72_0;
			if (obj == null)
			{
				UnityAction val3 = delegate
				{
					clearMainViewport();
					grantAdmin(grant: true);
					FilterItems(searchInput.text);
				};
				<>c.<>9__72_0 = val3;
				obj = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			GameObject val4 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component3 = ((Component)val4.transform.GetChild(0)).GetComponent<TMP_Text>();
			component3.text = "Revoke Admin Usage";
			Button component4 = val4.GetComponent<Button>();
			ButtonClickedEvent onClick2 = component4.onClick;
			object obj2 = <>c.<>9__72_1;
			if (obj2 == null)
			{
				UnityAction val5 = delegate
				{
					clearMainViewport();
					grantAdmin(grant: false);
					FilterItems(searchInput.text);
				};
				<>c.<>9__72_1 = val5;
				obj2 = (object)val5;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			GameObject val6 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component5 = ((Component)val6.transform.GetChild(0)).GetComponent<TMP_Text>();
			component5.text = "Despawn Item";
			Button component6 = val6.GetComponent<Button>();
			ButtonClickedEvent onClick3 = component6.onClick;
			object obj3 = <>c.<>9__72_2;
			if (obj3 == null)
			{
				UnityAction val7 = delegate
				{
					clearMainViewport();
					scrapDeletes();
					FilterItems(searchInput.text);
				};
				<>c.<>9__72_2 = val7;
				obj3 = (object)val7;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			GameObject val8 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component7 = ((Component)val8.transform.GetChild(0)).GetComponent<TMP_Text>();
			component7.text = "Despawn Enemy";
			Button component8 = val8.GetComponent<Button>();
			ButtonClickedEvent onClick4 = component8.onClick;
			object obj4 = <>c.<>9__72_3;
			if (obj4 == null)
			{
				UnityAction val9 = delegate
				{
					clearMainViewport();
					scrapDeletes();
					FilterItems(searchInput.text);
				};
				<>c.<>9__72_3 = val9;
				obj4 = (object)val9;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
		}

		public static void playerFunctions()
		{
			//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_006c: 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_00cf: Expected O, but got Unknown
			//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: Expected O, but got Unknown
			//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_0195: Expected O, but got Unknown
			//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_0207: Expected O, but got Unknown
			//IL_025f: 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_026a: Expected O, but got Unknown
			//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_02ee: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Scroll View/Viewport/Content");
			GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
			component.text = "Revive Player";
			Button component2 = val2.GetComponent<Button>();
			ButtonClickedEvent onClick = component2.onClick;
			object obj = <>c.<>9__73_0;
			if (obj == null)
			{
				UnityAction val3 = delegate
				{
					clearMainViewport();
					RevivePlayer();
					FilterItems(searchInput.text);
				};
				<>c.<>9__73_0 = val3;
				obj = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			GameObject val4 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component3 = ((Component)val4.transform.GetChild(0)).GetComponent<TMP_Text>();
			component3.text = "Teleport to Player";
			Button component4 = val4.GetComponent<Button>();
			ButtonClickedEvent onClick2 = component4.onClick;
			object obj2 = <>c.<>9__73_1;
			if (obj2 == null)
			{
				UnityAction val5 = delegate
				{
					clearMainViewport();
					TeleportPlayer();
					FilterItems(searchInput.text);
				};
				<>c.<>9__73_1 = val5;
				obj2 = (object)val5;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			GameObject val6 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component5 = ((Component)val6.transform.GetChild(0)).GetComponent<TMP_Text>();
			component5.text = "Bring Player";
			Button component6 = val6.GetComponent<Button>();
			ButtonClickedEvent onClick3 = component6.onClick;
			object obj3 = <>c.<>9__73_2;
			if (obj3 == null)
			{
				UnityAction val7 = delegate
				{
					clearMainViewport();
					TeleportPlayer(bring: true);
					FilterItems(searchInput.text);
				};
				<>c.<>9__73_2 = val7;
				obj3 = (object)val7;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			GameObject val8 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
			TMP_Text component7 = ((Component)val8.transform.GetChild(0)).GetComponent<TMP_Text>();
			component7.text = "Fix Player";
			Button component8 = val8.GetComponent<Button>();
			ButtonClickedEvent onClick4 = component8.onClick;
			object obj4 = <>c.<>9__73_3;
			if (obj4 == null)
			{
				UnityAction val9 = delegate
				{
					clearMainViewport();
					fixPlayer();
					FilterItems(searchInput.text);
				};
				<>c.<>9__73_3 = val9;
				obj4 = (object)val9;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			if (SelectEffect.isSpecial())
			{
				GameObject val10 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
				TMP_Text component9 = ((Component)val10.transform.GetChild(0)).GetComponent<TMP_Text>();
				component9.text = "Force Suit";
				Button component10 = val10.GetComponent<Button>();
				ButtonClickedEvent onClick5 = component10.onClick;
				object obj5 = <>c.<>9__73_4;
				if (obj5 == null)
				{
					UnityAction val11 = delegate
					{
						clearMainViewport();
						ForceSuitPlayerSelector();
						FilterItems(searchInput.text);
					};
					<>c.<>9__73_4 = val11;
					obj5 = (object)val11;
				}
				((UnityEvent)onClick5).AddListener((UnityAction)obj5);
				GameObject val12 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
				TMP_Text component11 = ((Component)val12.transform.GetChild(0)).GetComponent<TMP_Text>();
				component11.text = "Player Choose Ad";
				Button component12 = val12.GetComponent<Button>();
				ButtonClickedEvent onClick6 = component12.onClick;
				object obj6 = <>c.<>9__73_5;
				if (obj6 == null)
				{
					UnityAction val13 = delegate
					{
						clearMainViewport();
						ForcePlayerAd();
						FilterItems(searchInput.text);
					};
					<>c.<>9__73_5 = val13;
					obj6 = (object)val13;
				}
				((UnityEvent)onClick6).AddListener((UnityAction)obj6);
			}
			if (((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost || SelectEffect.isSpecial())
			{
				GameObject val14 = Object.Instantiate<GameObject>(MysteryDice.DebugSubButtonPrefab, val);
				TMP_Text component13 = ((Component)val14.transform.GetChild(0)).GetComponent<TMP_Text>();
				component13.text = "Kill Player";
				Button component14 = val14.GetComponent<Button>();
				ButtonClickedEvent onClick7 = component14.onClick;
				object obj7 = <>c.<>9__73_6;
				if (obj7 == null)
				{
					UnityAction val15 = delegate
					{
						clearMainViewport();
						killPlayer();
						FilterItems(searchInput.text);
					};
					<>c.<>9__73_6 = val15;
					obj7 = (object)val15;
				}
				((UnityEvent)onClick7).AddListener((UnityAction)obj7);
			}
			DebugMenuStuff.OnPlayerFunctionsAdded?.Invoke(subScrollContent);
		}

		public static void TeleportPlayer(bool bring = false)
		{
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (!player.isPlayerControlled)
				{
					continue;
				}
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = player.playerUsername ?? "";
				Button component2 = val2.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_003e: Unknown result type (might be due to invalid IL or missing references)
					CloseSelectMenu();
					PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
					if (localPlayerController.isPlayerDead && bring)
					{
						Networker.Instance.TeleportOrBringPlayerToPosServerRPC(((Component)StartOfRound.Instance.spectateCamera).transform.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player));
					}
					else
					{
						Networker.Instance.TeleportOrBringPlayerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), bring);
					}
					string text = "";
					text = ((!bring) ? ("Teleported to " + player.playerUsername) : ("Brought " + player.playerUsername + " to you!"));
					Misc.SafeTipMessage("Teleport", text);
				});
			}
		}

		public static void ForcePlayerAd()
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (player.isPlayerControlled)
				{
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
					TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = player.playerUsername ?? "";
					Button component2 = val2.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						CloseSelectMenu();
						Networker.Instance.ShowAdMenuServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player));
					});
				}
			}
		}

		public static void UnlockSomething()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			Terminal terminal = Object.FindFirstObjectByType<Terminal>();
			foreach (UnlockableItem item in StartOfRound.Instance.unlockablesList.unlockables)
			{
				if (!item.hasBeenUnlockedByPlayer)
				{
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
					TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = item.unlockableName;
					Button component2 = val2.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						StartOfRound.Instance.BuyShipUnlockableServerRpc(StartOfRound.Instance.unlockablesList.unlockables.IndexOf(item), terminal.groupCredits);
						CloseSelectMenu();
					});
				}
			}
		}

		public static void ForceSuitPlayerSelector()
		{
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (player.isPlayerControlled)
				{
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
					TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = player.playerUsername ?? "";
					Button component2 = val2.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						clearMainViewport();
						ForceSuitSuitSelector(player);
						FilterItems(searchInput.text);
					});
				}
			}
		}

		public static void ForceSuitSuitSelector(PlayerControllerB players)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_01a9: 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_01d5: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
			foreach (UnlockableSuit suit in Networker.orderedSuits)
			{
				string unlockableName = unlockables[suit.syncedSuitID.Value].unlockableName;
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = unlockableName ?? "";
				Button component2 = val2.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					Networker.Instance.suitStuffServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, players), suit.syncedSuitID.Value);
					CloseSelectMenu();
				});
			}
			GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component3 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
			component3.text = "Refresh Suits";
			((Graphic)component3).color = Color.red;
			Button component4 = val3.GetComponent<Button>();
			((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
			{
				Networker.orderedSuits = (from val4 in Object.FindObjectsOfType<UnlockableSuit>()
					orderby (val4.syncedSuitID.Value >= 0 && val4.syncedSuitID.Value < StartOfRound.Instance.unlockablesList.unlockables.Count) ? StartOfRound.Instance.unlockablesList.unlockables[val4.syncedSuitID.Value].unlockableName : string.Empty
					select val4).ToList();
				clearMainViewport();
				ForceSuitSuitSelector(players);
				FilterItems(searchInput.text);
			});
		}

		public static void RefreshRevives()
		{
			clearMainViewport();
			RevivePlayer();
			FilterItems(searchInput.text);
		}

		public static void RevivePlayer()
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			ReviveOpen = false;
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			int num = 0;
			foreach (PlayerControllerB player in source)
			{
				if (player.isPlayerDead)
				{
					num++;
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
					TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
					component.text = player.playerUsername ?? "";
					Button component2 = val2.GetComponent<Button>();
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						//IL_0048: Unknown result type (might be due to invalid IL or missing references)
						clearMainViewport();
						CloseSelectMenu();
						RevivePlayer();
						FilterItems(searchInput.text);
						Networker.Instance.RevivePlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), StartOfRound.Instance.middleOfShipNode.position);
						string text = "";
						text = "Revived " + player.playerUsername;
						Misc.SafeTipMessage("Revival", text);
					});
				}
			}
			if (num == 0)
			{
				GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component3 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
				component3.text = "No Dead Players";
			}
		}

		public static void ShowSelectMenu(bool fromSaint = false)
		{
			//IL_00fe: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			List<IEffect> ordered = getOrdered();
			foreach (IEffect effect in ordered)
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
				List<string> favorites = favoriteData.Favorites;
				bool flag = favorites.Contains(effect.Name);
				string text = (flag ? "*" : "");
				component.text = $"{text} {effect.Name} [{effect.Outcome}] {text}";
				((Graphic)component).color = (flag ? FavoriteTextColor : TextColor);
				component.outlineWidth = 1f;
				if (component.text.Length > 20)
				{
					component.fontSize = 12f;
				}
				else
				{
					component.fontSize = 16f;
				}
				Button component2 = val2.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu(fromSaint);
					if (diveGive)
					{
						Networker.Instance.SpawnCustomDieServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), effect.Name);
					}
					else
					{
						effect.Use();
						bool flag2 = false;
						string playerName = "";
						if (fromMe)
						{
							flag2 = true;
							playerName = StartOfRound.Instance.localPlayerController.playerUsername.ToString();
						}
						if (fromYippee)
						{
							flag2 = true;
							playerName = "An Enemy";
						}
						if (fromRandom)
						{
							flag2 = true;
							playerName = Misc.GetRandomPlayer().playerUsername.ToString();
						}
						if (flag2)
						{
							Networker.Instance.LogEffectsToOwnerServerRPC(playerName, effect.Name, (int)(effect.Outcome + 1));
						}
					}
				});
				RightClickHandler2 rightClickHandler = val2.AddComponent<RightClickHandler2>();
				rightClickHandler.effectName = effect.Name;
				rightClickHandler.category = "Favorites";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
				rightClickHandler.fromSaint = fromSaint;
			}
		}

		public static void ShowSoundMenu()
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			foreach (KeyValuePair<string, AudioClip> entry in MysteryDice.sounds.OrderBy((KeyValuePair<string, AudioClip> x) => x.Key))
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = entry.Key;
				component.outlineWidth = 1f;
				if (component.text.Length > 20)
				{
					component.fontSize = 12f;
				}
				else
				{
					component.fontSize = 16f;
				}
				Button component2 = val2.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					Networker.Instance.PlaySoundServerRPC(entry.Key);
				});
			}
		}

		public static void ShowJumpscareMenu()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			Transform val = EffectMenu.transform.Find("DebugMenu/Background/Scroll View/Viewport/Content");
			for (int i = 0; i < MysteryDice.JumpscareScript.scarePairs.Count; i++)
			{
				KeyValuePair<GameObject, ScareFace> keyValuePair = MysteryDice.JumpscareScript.scarePairs[i];
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component.text = (((Object)(object)keyValuePair.Key != (Object)null) ? ((Object)keyValuePair.Key).name : "(null)");
				component.outlineWidth = 1f;
				component.fontSize = ((component.text.Length > 20) ? 12 : 16);
				int index = i;
				Button component2 = val2.GetComponent<Button>();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					Networker.Instance.JumpscareAllServerRPC(index);
				});
			}
		}

		public static void ToggleFavorite(IEffect effect)
		{
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			if (favoriteData.Favorites.Contains(effect.Name))
			{
				favoriteData.Favorites.Remove(effect.Name);
			}
			else
			{
				favoriteData.Favorites.Add(effect.Name);
			}
			FavoriteEffectManager.SaveFavorites(favoriteData);
		}

		public static void CloseSelectMenu(bool force = false)
		{
			if ((MysteryDice.DebugMenuClosesAfter.Value || force) && (Object)(object)EffectMenu != (Object)null)
			{
				Cursor.visible = false;
				Cursor.lockState = (CursorLockMode)1;
				Object.Destroy((Object)(object)EffectMenu);
				if (MysteryDice.LockDebugUI.Value)
				{
					StartOfRound.Instance.localPlayerController.quickMenuManager.isMenuOpen = false;
				}
				DebugMenuStuff.OnSpecialFunctionsAdded = null;
				DebugMenuStuff.OnSpawnFunctionsAdded = null;
				DebugMenuStuff.OnPlayerFunctionsAdded = null;
			}
		}
	}
	internal class Delay : IEffect
	{
		public string Name => "Delayed Reaction";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Wait for it...";

		public void Use()
		{
			Networker.Instance.DelayedReactionServerRPC(Misc.GetRandomPlayerID());
		}

		public static void DelayedReaction(int userID)
		{
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (!((Object)(object)localPlayerController != (Object)(object)StartOfRound.Instance.allPlayerScripts[userID]))
			{
				int num = Random.Range(0, 7);
				IEffect randomEffect = GetRandomEffect(num);
				PlaySoundBasedOnEffect(randomEffect.Outcome);
				randomEffect.Use();
				string playerName = (((Object)(object)localPlayerController != (Object)null) ? localPlayerController.playerUsername : "An Enemy");
				Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				Misc.SafeTipMessage("NOW", randomEffect.Tooltip);
			}
		}

		public static void PlaySoundBasedOnEffect(EffectType effectType)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			AudioClip value;
			switch (effectType)
			{
			case EffectType.Awful:
				MysteryDice.sounds.TryGetValue("Bell2", out value);
				break;
			case EffectType.Bad:
				MysteryDice.sounds.TryGetValue("Bad1", out value);
				break;
			default:
				MysteryDice.sounds.TryGetValue("Good2", out value);
				break;
			}
			AudioSource.PlayClipAtPoint(value, ((Component)GameNetworkManager.Instance.localPlayerController).transform.position);
		}

		public static IEffect GetRandomEffect(int diceRoll)
		{
			List<IEffect> list = new List<IEffect>();
			switch (diceRoll)
			{
			case 0:
				list.AddRange(DieBehaviour.AwfulEffects);
				break;
			case 1:
				list.AddRange(DieBehaviour.AwfulEffects);
				list.AddRange(DieBehaviour.BadEffects);
				break;
			case 2:
				list.AddRange(DieBehaviour.BadEffects);
				break;
			case 3:
				list.AddRange(DieBehaviour.MixedEffects);
				break;
			case 4:
				list.AddRange(DieBehaviour.GoodEffects);
				list.AddRange(DieBehaviour.MixedEffects);
				break;
			case 5:
				list.AddRange(DieBehaviour.GoodEffects);
				break;
			case 6:
				list.AddRange(DieBehaviour.GoodEffects);
				list.AddRange(DieBehaviour.GreatEffects);
				break;
			}
			if (list.Count == 0)
			{
				return null;
			}
			int index = Random.Range(0, list.Count);
			return list[index];
		}
	}
	internal class Detonate : IEffect
	{
		public string Name => "Detonate";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "A random player will soon explode";

		public void Use()
		{
			Networker.Instance.DetonateRandomPlayerServerRpc();
		}
	}
	internal class DiversityEffect1 : IEffect
	{
		public string Name => "Stairs";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Down we go!";

		public void Use()
		{
			StartOfRoundRevamp.Instance.TeleportToStairsServerRpc((ulong)Misc.GetRandomPlayerID());
		}

		public static bool checkConfigs()
		{
			if (!Configuration.walker.Value)
			{
				return false;
			}
			return true;
		}
	}
	internal class DiversityEffect2 : IEffect
	{
		public string Name => "Diversity Bracken";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Get Kidnapped";

		public void Use()
		{
			StartOfRoundRevamp.Instance.KidnapServerRpc((ulong)Misc.GetRandomPlayerID());
		}

		public static bool checkConfigs()
		{
			if (!Configuration.brakenRevamp.Value)
			{
				return false;
			}
			return true;
		}
	}
	internal class DoorMalfunction : IEffect
	{
		public string Name => "Door malfunction";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Ship doors are malfunctioning!";

		public void Use()
		{
			Networker.Instance.StartMalfunctioningServerRPC();
		}

		public static void SetHangarDoorsState(bool closed)
		{
			HangarShipDoor[] array = Object.FindObjectsOfType<HangarShipDoor>();
			foreach (HangarShipDoor val in array)
			{
				val.SetDoorButtonsEnabled(false);
				if (closed)
				{
					val.SetDoorClosed();
				}
				else
				{
					val.SetDoorOpen();
				}
				val.doorPower = 20f;
				val.shipDoorsAnimator.SetBool("Closed", closed);
			}
		}
	}
	internal class DorjesDream : IEffect
	{
		public string Name => "Dorjes Dream";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Dreams of Dorje";

		public void Use()
		{
			//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_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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(1, 3), "Jetpack");
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(3, 5), "Spray paint");
		}
	}
	internal class DoubleTrouble : IEffect
	{
		public string Name => "Double Trouble";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "This could either be good or bad...";

		public void Use()
		{
			int roll = -1;
			string playerUsername = StartOfRound.Instance.localPlayerController.playerUsername;
			IEffect effect = (from _ in DieBehaviour.AllowedEffects.ToList()
				orderby Random.value
				select _).First();
			MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect in Double Trouble: " + effect.Name));
			effect.Use();
			Networker.Instance.LogEffectsToOwnerServerRPC(playerUsername, effect.Name, roll);
			IEffect effect2 = (from _ in DieBehaviour.AllowedEffects.ToList()
				orderby Random.value
				select _).First();
			MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect in Double Trouble: " + effect2.Name));
			effect2.Use();
			Networker.Instance.LogEffectsToOwnerServerRPC(playerUsername, effect2.Name, roll);
		}
	}
	internal class Drunk : IEffect
	{
		public static float DrunkTimer;

		public string Name => "Drunk";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Makes you a bit drunk";

		public void Use()
		{
			Networker.Instance.DrunkServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void FixedUpdate()
		{
			if (!(DrunkTimer <= 0f) && DrunkTimer > 0f)
			{
				DrunkTimer -= Time.fixedDeltaTime;
				BecomeDrunk(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
			}
		}

		public static void startDrinking(int userID)
		{
			if (!((Object)(object)StartOfRound.Instance.localPlayerController != (Object)(object)StartOfRound.Instance.allPlayerScripts[userID]))
			{
				DrunkTimer = Random.Range(10, 30);
			}
		}

		public static void BecomeDrunk(int userID)
		{
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			if (playerByUserID != null)
			{
				playerByUserID.drunkness = DrunkTimer;
				playerByUserID.drunknessInertia = DrunkTimer;
				playerByUserID.drunknessSpeed = DrunkTimer;
			}
		}
	}
	internal class DrunkForAll : IEffect
	{
		public static float DrunkTimer;

		public string Name => "$Drunk All";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Makes you a bit drunk";

		public void Use()
		{
			Networker.Instance.DrunkServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), All: true);
		}

		public static void startDrinking(int userID)
		{
			Drunk.DrunkTimer = Random.Range(10, 30);
		}
	}
	internal class EggBoots : IEffect
	{
		public static bool eggBootsEnabled = false;

		public static bool canSpawnAnother = true;

		public string Name => "Egg Boots";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Rocket Jump!";

		public void Use()
		{
			Networker.Instance.EggBootsServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void SpawnAndExplodeEgg(int playerid)
		{
			//IL_001a: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_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_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_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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: 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_015c: Unknown result type (might be due to invalid IL or missing references)
			Item itemByName = Misc.GetItemByName("Easter egg", matchCase: false);
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerid);
			Vector3 val = ((Component)playerByUserID).transform.position - ((Component)playerByUserID).transform.forward * 3.5f;
			val.y += 0.25f;
			GameObject val2 = Object.Instantiate<GameObject>(itemByName.spawnPrefab, val, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
			GameObject val3 = Object.Instantiate<GameObject>(itemByName.spawnPrefab, val, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
			GrabbableObject component = val2.GetComponent<GrabbableObject>();
			GrabbableObject component2 = val3.GetComponent<GrabbableObject>();
			((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
			((Component)component2).transform.rotation = Quaternion.Euler(component2.itemProperties.restingRotation);
			component.fallTime = 10f;
			component2.fallTime = 10f;
			NetworkObject component3 = val2.GetComponent<NetworkObject>();
			NetworkObject component4 = val3.GetComponent<NetworkObject>();
			component3.Spawn(false);
			component4.Spawn(false);
			Vector3 position = default(Vector3);
			((Vector3)(ref position))..ctor(val2.transform.position.x, val.y, val2.transform.position.z);
			Networker.Instance.explodeItemServerRPC(component3.NetworkObjectId, egg: true, 0, position);
			Networker.Instance.explodeItemServerRPC(component4.NetworkObjectId, egg: true, 0, position);
		}
	}
	public class EggNoKill : MonoBehaviour
	{
		public bool eggKill = false;
	}
	internal class EggBootsForAll : GalEffect, IEffect
	{
		public string Name => "Egg Boots ALL";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Rocket Jump!";

		public void Use()
		{
			Networker.Instance.EggBootsAllServerRpc();
		}
	}
	internal class EggFountain : IEffect
	{
		public string Name => "Surprise Eggs!!!";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Pop goes the egg!";

		public void Use()
		{
			Networker.Instance.EggFountainServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), 0);
		}

		public static void spawnEggs(int callerID, int choice)
		{
			//IL_00b8: 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_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_00ee: 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_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_0149: 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_0181: 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_01da: 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_0206: 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_0226: Unknown result type (might be due to invalid IL or missing references)
			Item val = null;
			Item itemByName = Misc.GetItemByName("Easter egg", matchCase: false);
			Item itemByName2 = Misc.GetItemByName("Stun grenade", matchCase: false);
			int num = 12;
			float num2 = 5f;
			int num3 = 0;
			List<GameObject> list = new List<GameObject>();
			List<NetworkObject> list2 = new List<NetworkObject>();
			List<Vector3> list3 = new List<Vector3>();
			bool egg = false;
			switch (choice)
			{
			case 0:
				val = itemByName;
				egg = true;
				break;
			case 1:
				val = itemByName2;
				num2 = 3f;
				break;
			default:
				val = itemByName;
				egg = true;
				break;
			}
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(callerID);
			if (!((Object)(object)playerByUserID == (Object)null))
			{
				Vector3 val2 = default(Vector3);
				for (int i = 0; i < num; i++)
				{
					float num4 = (float)i * MathF.PI * 2f / (float)num;
					((Vector3)(ref val2))..ctor(Mathf.Cos(num4) * num2, ((Component)playerByUserID).transform.position.y + 0.25f, Mathf.Sin(num4) * num2);
					val2 += ((Component)playerByUserID).transform.position;
					list3.Add(val2);
					GameObject val3 = Object.Instantiate<GameObject>(val.spawnPrefab, val2, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
					GrabbableObject component = val3.GetComponent<GrabbableObject>();
					((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
					component.fallTime = 0f;
					component.targetFloorPosition = val2;
					NetworkObject component2 = val3.GetComponent<NetworkObject>();
					component2.Spawn(false);
					CullFactorySoftCompat.RefreshGrabbableObjectPosition(val3.GetComponent<GrabbableObject>());
					val3.GetComponent<GrabbableObject>().EnablePhysics(true);
					component.FallToGround(false, true, val2);
					list.Add(val3);
					list2.Add(component2);
				}
				for (int j = 0; j < list2.Count; j++)
				{
					NetworkObject val4 = list2[j];
					Vector3 pos = list3[j];
					pos.y = ((Component)playerByUserID).transform.position.y;
					Networker.Instance.TeleportEggServerRPC(NetworkObjectReference.op_Implicit(val4), Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerByUserID), pos);
					Networker.Instance.explodeItemServerRPC(val4.NetworkObjectId, egg, num3);
					num3++;
				}
			}
		}

		public static void teleport(NetworkObjectReference netObjs, int userID, Vector3 pos)
		{
			//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_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_003c: 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_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_0080: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			NetworkObject val = default(NetworkObject);
			if (!((NetworkObjectReference)(ref netObjs)).TryGet(ref val, (NetworkManager)null))
			{
				return;
			}
			GameObject gameObject = ((Component)val).gameObject;
			if (!((Object)(object)gameObject == (Object)null))
			{
				Vector3 val2 = pos;
				RaycastHit val3 = default(RaycastHit);
				if (Physics.Raycast(val2 + Vector3.up, Vector3.down, ref val3))
				{
					val2 = ((RaycastHit)(ref val3)).point;
				}
				gameObject.transform.position = val2;
				GrabbableObject component = gameObject.GetComponent<GrabbableObject>();
				if ((Object)(object)component != (Object)null)
				{
					component.targetFloorPosition = val2;
				}
			}
		}

		public static IEnumerator explodeEgg(GameObject obj, int count)
		{
			yield return (object)new WaitForSeconds((float)count * MysteryDice.eggExplodeTime.Value);
			StunGrenadeItem stunGrenadeItem = obj.GetComponent<StunGrenadeItem>();
			if ((Object)(object)stunGrenadeItem != (Object)null)
			{
				stunGrenadeItem.chanceToExplode = 100f;
				MethodInfo explodeMethod = AccessTools.Method(((object)stunGrenadeItem).GetType(), "ExplodeStunGrenade", (Type[])null, (Type[])null);
				if (explodeMethod != null)
				{
					try
					{
						explodeMethod.Invoke(stunGrenadeItem, new object[1] { true });
					}
					catch (Exception ex)
					{
						Exception ex2 = ex;
						Debug.LogError((object)$"Failed to invoke ExplodeStunGrenade: {ex2}");
					}
				}
				else
				{
					Debug.LogError((object)"ExplodeStunGrenade method not found.");
				}
			}
			else
			{
				Debug.LogError((object)"StunGrenadeItem component missing on the object.");
			}
			EggBoots.canSpawnAnother = true;
		}

		public static IEnumerator explodeStun(GameObject obj)
		{
			yield return (object)new WaitForSeconds(1f);
			obj.GetComponent<StunGrenadeItem>().chanceToExplode = 100f;
			AccessTools.Method(((object)obj.GetComponent<StunGrenadeItem>()).GetType(), "ExplodeStunGrenade", (Type[])null, (Type[])null)?.Invoke(obj.GetComponent<StunGrenadeItem>(), new object[1] { true });
			yield return (object)new WaitForSeconds(0f);
		}
	}
	[HarmonyPatch(typeof(StunGrenadeItem), "ExplodeStunGrenade")]
	[HarmonyPatch(new Type[] { typeof(bool) })]
	public static class StunGrenadePatch
	{
		[HarmonyPostfix]
		public static void PostfixExplodeStunGrenade(bool __state)
		{
			MysteryDice.CustomLogger.LogDebug((object)"Stun grenade exploded");
		}
	}
	internal class FlashFountain : IEffect
	{
		public string Name => "Surprise Flash!!!";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Flashbang inbound!";

		public void Use()
		{
			Networker.Instance.EggFountainServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), 1);
		}
	}
	internal class Eggs : IEffect
	{
		public string Name => "Eggs";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "They Explode?!?";

		public void Use()
		{
			//IL_002f: 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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(3, 9), "Easter egg");
		}
	}
	internal class EmergencyMeeting : IEffect
	{
		public string Name => "Emergency Meeting";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "EMERGENCY MEETING";

		public void Use()
		{
			Networker.Instance.EmergencyMeetingServerRPC();
		}

		public static void allEnemiesToShip()
		{
			//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_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_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_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_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_010c: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyAI> spawnedEnemies = RoundManager.Instance.SpawnedEnemies;
			foreach (EnemyAI item in spawnedEnemies)
			{
				item.isOutside = true;
				item.allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
				item.serverPosition = StartOfRound.Instance.middleOfShipNode.position;
				Transform val = item.ChooseClosestNodeToPosition(item.serverPosition, true, 0);
				if (Vector3.Magnitude(val.position - item.serverPosition) > 10f)
				{
					item.serverPosition = val.position;
				}
				((Component)item).transform.position = item.serverPosition;
				item.agent.Warp(item.serverPosition);
				item.SyncPositionToClients();
				if ((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
				{
					item.EnableEnemyMesh(!StartOfRound.Instance.hangarDoorsClosed || !GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom, false, false);
				}
				MysteryDice.CustomLogger.LogInfo((object)$"Moving {((Object)item).name} to {item.serverPosition}");
			}
		}

		public static void TeleportEveryoneToShip()
		{
			List<int> list = new List<int>();
			GameObject[] allPlayerObjects = StartOfRound.Instance.allPlayerObjects;
			foreach (GameObject val in allPlayerObjects)
			{
				PlayerControllerB component = val.GetComponent<PlayerControllerB>();
				if (Misc.IsPlayerAliveAndControlled(component))
				{
					list.Add(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, component));
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			foreach (int item in list)
			{
				Networker.Instance.TeleportPlayerToShipServerRPC(item);
			}
		}

		public static void TeleportPlayerToShip(int who)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = null;
			val = StartOfRound.Instance.allPlayerScripts[who];
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			AudioReverbPresets val2 = Object.FindObjectOfType<AudioReverbPresets>();
			try
			{
				if (Object.op_Implicit((Object)(object)Object.FindObjectOfType<AudioReverbPresets>()))
				{
					Object.FindObjectOfType<AudioReverbPresets>().audioPresets[3].ChangeAudioReverbForPlayer(val);
				}
			}
			catch (Exception)
			{
			}
			val.isInElevator = false;
			val.isInHangarShipRoom = true;
			val.isInsideFactory = false;
			val.averageVelocity = 0f;
			val.velocityLastFrame = Vector3.zero;
			val.TeleportPlayer(StartOfRound.Instance.middleOfShipNode.position, false, 0f, false, true);
			val.beamOutParticle.Play();
			if ((Object)(object)val == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
			}
		}
	}
	internal class EtTuBrute : IEffect
	{
		public string Name => "Et Tu Brute";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Et tu, Brute?";

		public void Use()
		{
			//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)
			Networker.Instance.SpawnSurroundedServerRPC(GetEnemies.allEnemies.First((EnemyType x) => x.enemyName == "Lord Of The Manor").enemyName, 5, 2);
		}
	}
	internal class AllFly : GalEffect, IEffect
	{
		public string Name => "Everyone Can Fly!";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Double tap space to fly!!! (Like Minecraft!)";

		public void Use()
		{
			Networker.Instance.AllFlyServerRPC();
		}
	}
	internal class EveryoneToSomeone : IEffect
	{
		public string Name => "Everyone To Someone";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Sending Everyone to Someone!";

		public void Use()
		{
			TeleportEveryoneToSomeone(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}

		public static void TeleportEveryoneToSomeone(int callerID)
		{
			List<int> list = new List<int>();
			GameObject[] allPlayerObjects = StartOfRound.Instance.allPlayerObjects;
			foreach (GameObject val in allPlayerObjects)
			{
				PlayerControllerB component = val.GetComponent<PlayerControllerB>();
				if (Misc.IsPlayerAliveAndControlled(component))
				{
					list.Add(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, component));
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
			if ((Object)(object)randomAlivePlayer == (Object)null)
			{
				return;
			}
			int num = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomAlivePlayer);
			foreach (int item in list)
			{
				if (item != num)
				{
					Networker.Instance.TeleportToPlayerServerRPC(item, num);
				}
			}
		}

		public static void TeleportPlayerToPlayer(int who, int toWhom)
		{
			//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)
			PlayerControllerB val = null;
			PlayerControllerB val2 = null;
			val = StartOfRound.Instance.allPlayerScripts[who];
			val2 = StartOfRound.Instance.allPlayerScripts[toWhom];
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
			{
				AudioReverbPresets val3 = Object.FindObjectOfType<AudioReverbPresets>();
				if ((Object)(object)val3 != (Object)null)
				{
					val3.audioPresets[3].ChangeAudioReverbForPlayer(val);
				}
				val.isInElevator = val2.isInElevator;
				val.isInHangarShipRoom = val2.isInHangarShipRoom;
				val.isInsideFactory = val2.isInsideFactory;
				val.averageVelocity = 0f;
				val.velocityLastFrame = Vector3.zero;
				val.TeleportPlayer(((Component)val2).transform.position, false, 0f, false, true);
				val.beamOutParticle.Play();
				if ((Object)(object)val == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
				}
			}
		}
	}
	internal class EvilFreebirdEnemy : GalEffect, IEffect
	{
		public string Name => "Evil Freebird Enemy";

		public EffectType RealOutcome => EffectType.Mixed;

		public EffectType NoGalOutcome => EffectType.Bad;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Freebird that has a higher chance to target players";

		public void Use()
		{
			Networker.Instance.SpawnFreebirdEnemyServerRPC();
		}

		public static void spawnEnemy()
		{
			//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_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_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_008d: 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_00a8: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			EnemyType val = GetEnemies.allEnemies[Random.Range(0, GetEnemies.allEnemies.Count)];
			RoundManager instance = RoundManager.Instance;
			Vector3 zero = Vector3.zero;
			EnemyVent val2 = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
			zero = ((!val.isOutsideEnemy && !val.isDaytimeEnemy) ? val2.floorNode.position : instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position);
			GameObject val3 = Object.Instantiate<GameObject>(val.enemyPrefab, zero, Quaternion.identity);
			val3.transform.eulerAngles = new Vector3(val3.transform.eulerAngles.x, (float)Random.Range(0, 360), val3.transform.eulerAngles.z);
			NetworkObject component = val3.GetComponent<NetworkObject>();
			component.Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val3.GetComponent<EnemyAI>());
			Networker.Instance.FreebirdEnemyServerRPC(component.NetworkObjectId);
		}

		public static void fixEnemy(ulong id)
		{
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(id, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				freebirdMaker freebirdMaker2 = gameObject.gameObject.AddComponent<freebirdMaker>();
				freebirdMaker2.isEvil = true;
			}
		}

		public static void fixTrap(ulong id)
		{
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(id, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				gameObject.gameObject.AddComponent<freebirdTrapMaker>();
				if (MysteryDice.CodeRebirthPresent)
				{
					((MonoBehaviour)Networker.Instance).StartCoroutine(MovingBeartraps.fixSpiney(gameObject));
				}
			}
		}
	}
	internal class FakeFireExits : IEffect
	{
		public string Name => "Fake fire exits";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "More fire exits!";

		public void Use()
		{
			Networker.Instance.FakeFireExitsServerRPC();
		}
	}
	internal class Fans : IEffect
	{
		public static int MaxMinesToSpawn = 5;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Fans";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "I'm a big fan!";

		public void Use()
		{
			Networker.Instance.CustomTrapServerRPC(MaxMinesToSpawn, ((Object)GetEnemies.Fan.prefabToSpawn).name, inside: false);
		}
	}
	internal class FireExitBlock : IEffect
	{
		public string Name => "Fire exit block";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Fire exits blocked!";

		public void Use()
		{
			Networker.Instance.BlockFireExitsServerRPC();
		}
	}
	internal class Flashers : IEffect
	{
		public static int MaxMinesToSpawn = 5;

		public string Name => "Flashers";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "They gonna flash ya!";

		public void Use()
		{
			Networker.Instance.CustomTrapServerRPC(MaxMinesToSpawn, ((Object)GetEnemies.FlashTurret.prefabToSpawn).name, inside: false);
		}
	}
	internal class Flinger : IEffect
	{
		public class TopSpin : MonoBehaviour
		{
			public float spinSpeed = 10000f;

			private void Update()
			{
				//IL_0007: 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)
				((Component)this).transform.Rotate(Vector3.up * (spinSpeed * Time.deltaTime));
			}
		}

		public static ConfigEntry<bool> beybladeMode;

		public string Name => "Flinger";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Get Flung";

		public void Use()
		{
			if (GetEnemies.Horse != null)
			{
				Networker.Instance.spawnFlingerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
			}
		}

		public static void spawnHorseshoe(int userID)
		{
			//IL_001d: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.Horse.enemyType.enemyPrefab, ((Component)playerByUserID).transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			if (beybladeMode.Value)
			{
				val.AddComponent<TopSpin>();
			}
			RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			Networker.Instance.setHorseStuffServerRPC(val.GetComponent<NetworkObject>().NetworkObjectId);
		}

		public static void horseStuff(GameObject obj)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				obj.GetComponent<HorseAI>().launchForceIndex = 2;
				((Renderer)obj.GetComponents<SkinnedMeshRenderer>()[0]).materials[1].SetColor("red", Color.red);
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogWarning((object)("Small Error: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		public static void Config()
		{
			beybladeMode = MysteryDice.BepInExConfig.Bind<bool>("Flinger", "Beyblade", false, "Makes the flinger a Beyblade Flinger");
		}
	}
	internal class Fly : IEffect
	{
		public static bool CanFly = false;

		public static float lastTapTime = -1f;

		public static float tapCooldown = 0.3f;

		public static int tapCount = 0;

		public static bool isFlying = false;

		public string Name => "Fly";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Double tap space to fly!!! (Like Minecraft!)";

		public void Use()
		{
			CanFly = true;
		}
	}
	internal class FollowerFan : IEffect
	{
		public string Name => "Follower Fan";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Your new best friend!";

		public void Use()
		{
			Networker.Instance.DoFollowerFanServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
		}

		public static void giveFriend(int playerID)
		{
			//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_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_00a6: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerID);
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.Fan.prefabToSpawn, ((Component)playerByUserID).transform.position - ((Component)playerByUserID).transform.forward * 3f, Quaternion.identity);
			((Object)val).name = "FollowerFan" + Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerByUserID);
			NetworkObject component = val.GetComponent<NetworkObject>();
			((Component)val.GetComponentInChildren<IndustrialFanBackCollider>()).gameObject.SetActive(false);
			component.Spawn(false);
			Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3(0.4f, 0.4f, 0.4f));
			Networker.Instance.AddMovingTrapClientRPC(((Object)val).name, follower: true, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, playerByUserID));
		}

		public static void fixFan(GameObject fan)
		{
			IndustrialFanBackCollider componentInChildren = fan.GetComponentInChildren<IndustrialFanBackCollider>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Component)componentInChildren).gameObject.SetActive(false);
			}
			IndustrialFanBackCollider componentInChildren2 = fan.GetComponentInChildren<IndustrialFanBackCollider>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				IndustrialFan industrialFan = componentInChildren2.industrialFan;
				industrialFan.pushForce *= -1f;
			}
		}
	}
	internal class ForceTakeoff : IEffect
	{
		public string Name => "Force Takeoff";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Forces the ship to Takeoff";

		public void Use()
		{
			Networker.Instance.ForceTakeoffServerRPC();
		}
	}
	internal class ForceUpdateScannodes : IEffect
	{
		public string Name => "Force Update Scannodes";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Forces Scan nodes to Update";

		public void Use()
		{
			Networker.Instance.forceUpdatePlayers();
		}
	}
	internal class FreebirdEnemy : IEffect
	{
		public string Name => "Freebird Enemy";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "FREEBIRDDDDDDDDDDDDDDDDDDDDDD YEAH";

		public void Use()
		{
			Networker.Instance.SpawnFreebirdEnemyServerRPC();
		}

		public static void spawnEnemy()
		{
			//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_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_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_008d: 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_00a8: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			EnemyType val = GetEnemies.allEnemies[Random.Range(0, GetEnemies.allEnemies.Count)];
			RoundManager instance = RoundManager.Instance;
			Vector3 zero = Vector3.zero;
			EnemyVent val2 = instance.allEnemyVents[Random.Range(0, instance.allEnemyVents.Length)];
			zero = ((!val.isOutsideEnemy && !val.isDaytimeEnemy) ? val2.floorNode.position : instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position);
			GameObject val3 = Object.Instantiate<GameObject>(val.enemyPrefab, zero, Quaternion.identity);
			val3.transform.eulerAngles = new Vector3(val3.transform.eulerAngles.x, (float)Random.Range(0, 360), val3.transform.eulerAngles.z);
			NetworkObject component = val3.GetComponent<NetworkObject>();
			component.Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val3.GetComponent<EnemyAI>());
			Networker.Instance.FreebirdEnemyServerRPC(component.NetworkObjectId);
		}

		public static void spawnEnemy(string name, Vector3 pos)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			EnemyType val = GetEnemies.allEnemies.Find((EnemyType x) => x.enemyName == name);
			GameObject val2 = Object.Instantiate<GameObject>(val.enemyPrefab, pos, Quaternion.identity);
			val2.transform.eulerAngles = new Vector3(val2.transform.eulerAngles.x, (float)Random.Range(0, 360), val2.transform.eulerAngles.z);
			NetworkObject component = val2.GetComponent<NetworkObject>();
			component.Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
			Networker.Instance.FreebirdEnemyServerRPC(component.NetworkObjectId);
		}

		public static void fixEnemy(ulong id)
		{
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(id, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				gameObject.gameObject.AddComponent<freebirdMaker>();
			}
		}

		public static void fixTrap(ulong id)
		{
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(id, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				gameObject.gameObject.AddComponent<freebirdTrapMaker>();
				if (MysteryDice.CodeRebirthPresent)
				{
					((MonoBehaviour)Networker.Instance).StartCoroutine(MovingBeartraps.fixSpiney(gameObject));
				}
			}
		}
	}
	public class freebirdMaker : MonoBehaviour
	{
		public NavMeshAgent agent;

		private AudioSource audiosrc;

		private EnemyAI _enemyAI;

		public bool isEvil = false;

		public void Start()
		{
			if ((Object)(object)agent == (Object)null)
			{
				agent = ((Component)this).gameObject.GetComponent<NavMeshAgent>();
			}
			if (!((Object)(object)agent == (Object)null))
			{
				if ((Object)(object)_enemyAI == (Object)null)
				{
					_enemyAI = ((Component)this).gameObject.GetComponent<EnemyAI>();
				}
				audiosrc = ((Component)this).gameObject.AddComponent<AudioSource>();
				Networker.Instance.FreebirdAudioSources.Add(audiosrc);
				audiosrc.loop = true;
				audiosrc.playOnAwake = true;
				audiosrc.maxDistance = 30f;
				audiosrc.minDistance = 0f;
				audiosrc.volume = MysteryDice.SoundVolume.Value;
				audiosrc.rolloffMode = (AudioRolloffMode)2;
				audiosrc.spatialBlend = 1f;
				audiosrc.dopplerLevel = 0f;
				if (MysteryDice.CopyrightFree.Value)
				{
					AudioSource obj = audiosrc;
					obj.volume -= 0.08f;
					audiosrc.clip = MysteryDice.LoadedAssets2.LoadAsset<AudioClip>("SpazzmaticaPolka");
				}
				else
				{
					audiosrc.clip = MysteryDice.LoadedAssets2.LoadAsset<AudioClip>("Freebird");
				}
				audiosrc.Play();
			}
		}

		public void OnDestroy()
		{
			Networker.Instance.FreebirdAudioSources.Remove(audiosrc);
		}

		public void Update()
		{
			//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)
			if (_enemyAI.isEnemyDead)
			{
				audiosrc.Stop();
				Object.Destroy((Object)(object)this);
			}
			if ((Object)(object)agent == (Object)null)
			{
				return;
			}
			agent.acceleration = 999f;
			agent.angularSpeed = 360f;
			agent.speed = 20f;
			if (isEvil)
			{
				PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
				if ((Object)(object)randomAlivePlayer != (Object)null && agent.isOnNavMesh)
				{
					Debug.Log((object)$"Setting destination to {((Object)randomAlivePlayer).name} at {((Component)randomAlivePlayer).transform.position}");
					agent.destination = ((Component)randomAlivePlayer).transform.position;
				}
				else
				{
					Debug.LogWarning((object)"No valid target or agent not on NavMesh.");
				}
			}
		}
	}
	public class freebirdTrapMaker : MonoBehaviour
	{
		public NavMeshAgent agent;

		private AudioSource audiosrc;

		public bool isEvil = false;

		public void Start()
		{
			if ((Object)(object)agent == (Object)null)
			{
				agent = ((Component)this).gameObject.GetComponent<NavMeshAgent>();
			}
			if (!((Object)(object)agent == (Object)null))
			{
				audiosrc = ((Component)this).gameObject.AddComponent<AudioSource>();
				audiosrc.loop = true;
				audiosrc.maxDistance = 30f;
				audiosrc.minDistance = 0f;
				audiosrc.volume = 0.8f;
				audiosrc.rolloffMode = (AudioRolloffMode)2;
				audiosrc.spatialBlend = 1f;
				audiosrc.dopplerLevel = 0f;
				if (MysteryDice.CopyrightFree.Value)
				{
					AudioSource obj = audiosrc;
					obj.volume -= 0.08f;
					audiosrc.clip = MysteryDice.LoadedAssets2.LoadAsset<AudioClip>("SpazzmaticaPolka");
				}
				else
				{
					audiosrc.clip = MysteryDice.LoadedAssets2.LoadAsset<AudioClip>("Freebird");
				}
				audiosrc.Play();
			}
		}

		public void Update()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)agent == (Object)null))
			{
				agent.acceleration = 999f;
				agent.angularSpeed = 360f;
				agent.speed = 10f;
				if (isEvil)
				{
					agent.destination = ((Component)Misc.GetRandomAlivePlayer()).transform.position;
				}
			}
		}
	}
	internal class FreebirdJimothy : IEffect
	{
		public string Name => "Freebird Jimothy";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "FREEBIRD";

		public void Use()
		{
			Networker.Instance.SpawnFreebirdJimothyServerRPC();
		}

		public static void spawnJimothy()
		{
			//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_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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = RoundManager.Instance.outsideAINodes[Random.Range(0, RoundManager.Instance.outsideAINodes.Length - 1)].transform.position;
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.Jimothy.enemyType.enemyPrefab, position, Quaternion.identity);
			val.transform.eulerAngles = new Vector3(val.transform.eulerAngles.x, (float)Random.Range(0, 360), val.transform.eulerAngles.z);
			NetworkObject component = val.GetComponent<NetworkObject>();
			component.Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			Networker.Instance.FreebirdJimothyServerRPC(component.NetworkObjectId);
		}

		public static void fixJimothy(ulong id)
		{
			int num = 19;
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(id, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				Transporter component = gameObject.GetComponent<Transporter>();
				((Component)component).gameObject.AddComponent<freebirdMaker>();
				component.speedIncrease = num;
			}
		}
	}
	internal class FreebirdTrap : IEffect
	{
		public string Name => "Freebird Trap";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "FREEBIRDDDDDDDDDDDDDDDDDDDDDD YEAH";

		public void Use()
		{
			Networker.Instance.SpawnFreebirdTrapServerRPC("landmine", random: true);
		}
	}
	public interface GalEffect : IEffect
	{
		EffectType RealOutcome { get; }

		EffectType NoGalOutcome { get; }
	}
	internal class Ghosts : IEffect
	{
		public string Name => "The Shining";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Come and play with us. Forever... and ever... and ever";

		public void Use()
		{
			Networker.Instance.SpawnGhostsServerRPC();
		}

		public static void SpawnGhosts()
		{
			if (GetEnemies.Ghost != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Ghost, 2, isInside: true);
			}
		}
	}
	internal class GiveAllDice : IEffect
	{
		public string Name => "ALL DICE";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "ALL DICE";

		public void Use()
		{
			Networker.Instance.GiveAllDiceServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(0, MysteryDice.RegisteredDice.Count()));
		}

		public static void DiceScrap(int userID)
		{
			//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_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_0151: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			RoundManager instance = RoundManager.Instance;
			List<Item> list = new List<Item>();
			List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
			List<int> list3 = new List<int>();
			List<float> list4 = new List<float>();
			foreach (Item registeredDie in MysteryDice.RegisteredDice)
			{
				list.Add(registeredDie);
			}
			foreach (Item item in list)
			{
				GameObject val = Object.Instantiate<GameObject>(item.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
				component.fallTime = 0f;
				component.scrapValue = (int)((float)Random.Range(item.minValue, item.maxValue) * instance.scrapValueMultiplier);
				list3.Add(component.scrapValue);
				list4.Add(component.itemProperties.weight);
				NetworkObject component2 = val.GetComponent<NetworkObject>();
				component2.Spawn(false);
				CullFactorySoftCompat.RefreshGrabbableObjectPosition(val.GetComponent<GrabbableObject>());
				val.GetComponent<GrabbableObject>().EnablePhysics(true);
				component.FallToGround(false, true, ((Component)playerByUserID).transform.position);
				list2.Add(NetworkObjectReference.op_Implicit(component2));
			}
			((MonoBehaviour)instance).StartCoroutine(DelayedSync(instance, list2.ToArray(), list3.ToArray(), list4.ToArray()));
		}

		public static IEnumerator DelayedSync(RoundManager RM, NetworkObjectReference[] netObjs, int[] scrapValues, float[] scrapWeights)
		{
			yield return (object)new WaitForSeconds(3f);
			RM.SyncScrapValuesClientRpc(netObjs, scrapValues);
			Networker.Instance.SyncItemWeightsClientRPC(netObjs, scrapWeights);
		}
	}
	internal class GiveCredits : IEffect
	{
		public string Name => "More Money";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Credits Were Given!";

		public void Use()
		{
			Networker.Instance.AddMoneyServerRPC(Random.Range(100, 400));
		}
	}
	internal class Glitch : IEffect
	{
		public string Name => "Glitch";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "( • \u0300ω •\u0301 )\n";

		public void Use()
		{
			Misc.SafeTipMessage("( • \u0300ω •\u0301 )\n", "");
		}
	}
	internal class GoldenTouch : IEffect
	{
		public string Name => "Golden Touch";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Doubles the value of a random item in your inventory";

		public void Use()
		{
			Networker.Instance.GoldenTouchServerRPC();
		}

		public static int GetRandomItem(int userID)
		{
			PlayerControllerB val = null;
			val = Misc.GetPlayerByUserID(userID);
			if ((Object)(object)val == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"Player not found.");
				return -1;
			}
			Dictionary<GrabbableObject, int> dictionary = new Dictionary<GrabbableObject, int>();
			for (int i = 0; i < val.ItemSlots.Length; i++)
			{
				GrabbableObject val2 = val.ItemSlots[i];
				if ((Object)(object)val2 != (Object)null && val2.scrapValue > 0)
				{
					dictionary.Add(val2, i);
				}
			}
			if (dictionary.Count == 0)
			{
				Debug.LogError((object)"No valid items with non-zero scrapValue found.");
				return -1;
			}
			int index = Random.Range(0, dictionary.Count);
			return dictionary.ElementAt(index).Value;
		}
	}
	internal class GuardsmanOutside : IEffect
	{
		public string Name => "GuardsmanOutside";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Just a phone call away!";

		public void Use()
		{
			Networker.Instance.CustomMonsterServerRPC("Guardsman", 3, 5, IsInside: false);
		}
	}
	internal class HappyDay : IEffect
	{
		public string Name => "Stuffing For Days";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Lizzie's Paradise";

		public void Use()
		{
			//IL_002f: 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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(6, 12), "plushies");
		}
	}
	internal class HappyFamily : IEffect
	{
		public string Name => "Happy Family";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "One Big Happy Family!";

		public void Use()
		{
			Networker.Instance.CustomMonsterServerRPC("Mistress", 1, 1, IsInside: true);
			Networker.Instance.CustomMonsterServerRPC("Lord Of The Manor", 1, 1, IsInside: true);
			Networker.Instance.CustomMonsterServerRPC("Rabbit Magician", 1, 1, IsInside: true);
			Networker.Instance.CustomMonsterServerRPC("Girl", 1, 1, IsInside: true);
		}
	}
	internal class HealAndRestore : IEffect
	{
		public string Name => "Full restore";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Healing everyone and recharging their batteries";

		public void Use()
		{
			Networker.Instance.HealAllServerRPC();
		}
	}
	internal class HeavyBurden : IEffect
	{
		public string Name => "Heavy Burden";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Makes everything in your inventory a bit heavier";

		public void Use()
		{
			Networker.Instance.HeavyBurdenServerRPC();
		}

		public static void increaseWeight(int userID)
		{
			Misc.AdjustWeight(userID, 2f);
		}
	}
	internal class Hehehe : IEffect
	{
		public static GameObject spiderCanvas;

		public string Name => "Hehehe";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Hehehe";

		public void Use()
		{
			Networker.Instance.HeheheServerRpc(Misc.GetRandomPlayerID());
		}
	}
	internal class Horseshootnt : IEffect
	{
		public string Name => "Horseshootnt";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE";

		public void Use()
		{
			Networker.Instance.SuperFlingerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
		}

		public static void spawnFlinger(int playerId)
		{
			//IL_001d: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerId);
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.Horse.enemyType.enemyPrefab, ((Component)playerByUserID).transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			Networker.Instance.setHorseStuffServerRPC(val.GetComponent<NetworkObject>().NetworkObjectId, 2);
		}

		public static void horseStuff(GameObject obj)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				obj.GetComponent<HorseAI>().launchForceIndex = 0;
				HorseAI component = obj.GetComponent<HorseAI>();
				component.launchForcesPerLevel = new float[3] { -75f, -125f, -200f };
				((Renderer)obj.GetComponents<SkinnedMeshRenderer>()[0]).materials[1].SetColor("Green", Color.green);
			}
			catch
			{
			}
		}
	}
	internal class HorseshootSeat : IEffect
	{
		public string Name => "Horseshoot Seat";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Horseshoot Seat";

		public void Use()
		{
			Networker.Instance.HorseSeatServerRpc();
		}

		public static void HorseSeat()
		{
			//IL_005a: 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_0078: 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_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)
			VehicleController val = Object.FindObjectsOfType<VehicleController>().FirstOrDefault();
			if ((Object)(object)val != (Object)null)
			{
				Transform val2 = ((Component)val).gameObject.transform.Find("Triggers").Find("DriverSide").Find("DriverSeatPositionNode");
				GameObject val3 = Object.Instantiate<GameObject>(GetEnemies.Horse.enemyType.enemyPrefab, ((Component)val2).transform.position - new Vector3(0f, 0.2f, 0f), Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				val3.transform.eulerAngles = new Vector3(val3.transform.eulerAngles.x, (float)Random.Range(0, 360), val3.transform.eulerAngles.z);
				NetworkObject component = val3.GetComponent<NetworkObject>();
				component.Spawn(true);
			}
		}
	}
	internal class HouseAlwaysWins : GalEffect, IEffect
	{
		public string Name => "House Always Wins";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Awful;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "We Always win";

		public void Use()
		{
			Networker.Instance.HouseWinServerRPC();
		}

		public static void Spawn()
		{
			//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_0060: 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_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)
			int num = Random.Range(3, 6);
			if (GetEnemies.Masked == null)
			{
				return;
			}
			for (int i = 0; i < num; i++)
			{
				Vector3 position = StartOfRound.Instance.middleOfShipNode.position;
				GameObject val = Object.Instantiate<GameObject>(GetEnemies.allEnemies.Find((EnemyType x) => x.enemyName == "Baboon hawk").enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				val.GetComponentInChildren<NetworkObject>().Spawn(true);
				RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
				NetworkObjectReference val2 = NetworkObjectReference.op_Implicit(val.GetComponentInChildren<NetworkObject>());
			}
		}
	}
	internal class HyperShake : IEffect
	{
		public class ShakeData
		{
			public PlayerControllerB Player;

			public float NextShakeTimer;

			public float ShakingTimer;

			public float Force = 0f;
		}

		public static int timer = -1;

		public static bool isTimerRunning = false;

		public static ShakeData ShakingData = null;

		public string Name => "Hyper Shake";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Makes you shake a lot!";

		public void Use()
		{
			timer = MysteryDice.hyperShakeTimer.Value;
			Networker.Instance.HyperShakeServerRPC();
		}

		public static void FixedUpdate()
		{
			if (ShakingData == null)
			{
				return;
			}
			ShakingData.NextShakeTimer -= Time.fixedDeltaTime;
			if (ShakingData.NextShakeTimer < 0f)
			{
				ShakingData.ShakingTimer = Random.Range(2f, 4f);
				ShakingData.NextShakeTimer = Random.Range(5f, 40f);
				float value = MysteryDice.minHyperShake.Value;
				float num = MysteryDice.maxHyperShake.Value;
				if (num < value)
				{
					num = value;
				}
				ShakingData.Force = Random.Range(value, num);
			}
			if (ShakingData.ShakingTimer > 0f)
			{
				ShakingData.ShakingTimer -= Time.fixedDeltaTime;
				Shake(ShakingData);
			}
		}

		public static void Shake(ShakeData data)
		{
			//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_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)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(Random.Range(-5f, 5f) * Mathf.Sin(Time.time), Random.Range(-0.01f, 1f), Random.Range(-5f, 5f) * Mathf.Sin(Time.time));
			PlayerControllerB player = data.Player;
			player.externalForces += val * data.Force;
		}

		public static IEnumerator WaitTime()
		{
			isTimerRunning = true;
			MysteryDice.CustomLogger.LogInfo((object)$"Shaking for {timer} seconds");
			yield return (object)new WaitForSeconds((float)timer);
			ShakingData = null;
			isTimerRunning = false;
		}
	}
	public enum EffectType
	{
		Awful,
		Bad,
		Mixed,
		Good,
		Great,
		Penalty,
		SpecialPenalty,
		GalOnly
	}
	public interface IEffect
	{
		EffectType Outcome { get; }

		bool ShowDefaultTooltip { get; }

		string Name { get; }

		string Tooltip { get; }

		void Use();
	}
	internal class IFeelSafe : IEffect
	{
		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "I Feel Safe";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "I Feel Safe";

		public void Use()
		{
			Networker.Instance.IFeelSafeServerRPC();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void SpawnCratesOutside(float positionOffsetRadius = 5f)
		{
			//IL_003e: 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_0049: 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_0057: 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_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_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_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_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_00cd: 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_00f6: 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)
			GameObject randomCrate = CratesOutside.getRandomCrate();
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			int num = 100;
			Vector3 position = RoundManager.Instance.outsideAINodes[Random.Range(0, RoundManager.Instance.outsideAINodes.Length - 1)].transform.position;
			Vector3 val = RoundManager.Instance.GetRandomNavMeshPositionInBoxPredictable(position, 10f, default(NavMeshHit), random, -1, 1f) + Vector3.up * 2f;
			RaycastHit val2 = default(RaycastHit);
			Physics.Raycast(val, Vector3.down, ref val2, 100f, StartOfRound.Instance.collidersAndRoomMaskAndDefault);
			if ((Object)(object)((RaycastHit)(ref val2)).collider != (Object)null)
			{
				Vector3 val3 = ((RaycastHit)(ref val2)).point + ((RaycastHit)(ref val2)).normal * -0.75f;
				GameObject val4 = Object.Instantiate<GameObject>(randomCrate, val3, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				val4.transform.up = ((RaycastHit)(ref val2)).normal;
				val4.GetComponent<NetworkObject>().Spawn(false);
				SceneManager.MoveGameObjectToScene(val4, RoundManager.Instance.mapPropsContainer.scene);
				Networker.Instance.TeleportOrBringPlayerToPosServerRPC(val4.transform.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class IHearDeadPeople : IEffect
	{
		public static bool isSixthSensed;

		public string Name => "I Hear Dead People";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Off Brand Sixth Sense";

		public void Use()
		{
			isSixthSensed = true;
		}

		public static void Update()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!((Object)(object)val == (Object)null) && val.isPlayerDead && !((Object)(object)val == (Object)(object)StartOfRound.Instance.localPlayerController))
				{
					AudioSource currentVoiceChatAudioSource = val.currentVoiceChatAudioSource;
					if (!((Object)(object)currentVoiceChatAudioSource == (Object)null))
					{
						currentVoiceChatAudioSource.volume = 1f;
						currentVoiceChatAudioSource.pitch = 1f;
						((Component)currentVoiceChatAudioSource).transform.position = val.spectateCameraPivot.position;
					}
				}
			}
		}
	}
	internal class ImmortalSnailcat : IEffect
	{
		public string Name => "Immortal Snailcat";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Immortal Snail(Cat)";

		public void Use()
		{
			Networker.Instance.doImmortalSnailCatServerRPC(1);
		}
	}
	internal class IncreasedRate : IEffect
	{
		public string Name => "Increased Rate";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Increased company buying rate for this quota";

		public void Use()
		{
			Networker.Instance.IncreaseRateServerRPC();
		}
	}
	internal class InfiniteStamina : IEffect
	{
		public string Name => "Infinite stamina";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Infinite stamina for you";

		public void Use()
		{
			PlayerControllerBPatch.HasInfiniteStamina = true;
		}
	}
	internal class InfiniteStaminaAll : IEffect
	{
		public string Name => "Global infinite stamina";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Infinite stamina for everyone";

		public void Use()
		{
			Networker.Instance.InfiniteStaminaAllServerRPC();
		}
	}
	internal class InsideDog : IEffect
	{
		public string Name => "Inside Dog";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Can I pet that Dawg";

		public void Use()
		{
			if (GetEnemies.Dog != null)
			{
				Networker.Instance.PlaySoundServerRPC("Dawg");
				Misc.SpawnEnemyForced(GetEnemies.Dog, 1, isInside: true);
			}
		}
	}
	internal class InsideGiant : IEffect
	{
		public string Name => "Inside Giant";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "A giant has been spotted inside";

		public void Use()
		{
			if (GetEnemies.Giant != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Giant, 1, isInside: true);
			}
		}
	}
	internal class InsideShrimps : IEffect
	{
		public string Name => "Inside Shrimps";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "SHRIMPS";

		public void Use()
		{
			int amount = Random.Range(5, 10);
			if (GetEnemies.Shrimp != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Shrimp, amount, isInside: true);
			}
		}
	}
	internal class InstaJester : IEffect
	{
		public string Name => "Instajester";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Spawned a popped jester!";

		public void Use()
		{
			Networker.Instance.InstaJesterServerRPC();
		}

		public static void SpawnInstaJester()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			if (GetEnemies.Jester == null)
			{
				return;
			}
			Misc.SpawnEnemyForced(GetEnemies.Jester, 1, isInside: true);
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (spawnedEnemy is JesterAI)
				{
					JesterAI val = (JesterAI)spawnedEnemy;
					((EnemyAI)val).SwitchToBehaviourState(1);
					((MonoBehaviour)val).StartCoroutine(DelayPop(val));
				}
			}
		}

		public static IEnumerator DelayPop(JesterAI jester)
		{
			yield return (object)new WaitForSeconds(1f);
			((EnemyAI)jester).SwitchToBehaviourState(2);
		}
	}
	internal class ManyMistress : IEffect
	{
		public string Name => "ManyMistress";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Head Choppin Time";

		public void Use()
		{
			Networker.Instance.spawnMistressServerRPC();
		}

		public static void SpawnMistress()
		{
			if (((NetworkBehaviour)Networker.Instance).IsHost)
			{
				Networker.Instance.CustomMonsterServerRPC("Mistress", 3, 5, IsInside: false);
			}
		}
	}
	internal class InstantExplodingBerthas : IEffect
	{
		public static int MinMinesToSpawn = 2;

		public static int MaxMinesToSpawn = 5;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "IEBertha";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You might die";

		public void Use()
		{
			Networker.Instance.InstantExplodeBerthaServerRPC();
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public unsafe static void SpawnBerthaOutside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: 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_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_014c: 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_017f: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.Bertha.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								val4.GetComponent<NetworkObject>().Spawn(true);
								num++;
								Bertha componentInChildren = val4.GetComponentInChildren<Bertha>();
								Networker.Instance.setExplodedServerRpc(((NetworkBehaviour)componentInChildren).NetworkObject.NetworkObjectId, 1.5f);
							}
						}
					}
					if (!flag)
					{
						ManualLogSource customLogger = MysteryDice.CustomLogger;
						Vector3 val5 = position;
						customLogger.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static IEnumerator DetonateDelay2(PlayerControllerB playerWhoCollided, ulong bertharef, float time)
		{
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(bertharef, out var networkObj))
			{
				GameObject obj = ((Component)networkObj).gameObject;
				Bertha bertha = obj.GetComponent<Bertha>();
				bertha.mineAudio.PlayOneShot(bertha.mineTrigger, 1f);
				yield return (object)new WaitForSeconds(time);
				bertha.Detonate(playerWhoCollided);
				bertha.BoomLight.SetActive(true);
				yield return (object)new WaitForSeconds(0.1f);
				((Component)((Component)((Component)bertha).transform.parent).transform.Find("BigBertha")).gameObject.SetActive(false);
				yield return (object)new WaitForSeconds(0.2f);
				bertha.BoomLight.SetActive(false);
				Collider[] componentsInChildren = ((Component)bertha).GetComponentsInChildren<Collider>();
				foreach (Collider collider in componentsInChildren)
				{
					collider.enabled = false;
				}
				yield return (object)new WaitForSeconds(10f);
				if (((NetworkBehaviour)StartOfRound.Instance).IsServer)
				{
					((NetworkBehaviour)bertha).NetworkObject.Despawn(true);
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class InvertDoorLock : IEffect
	{
		public string Name => "Inverted door lock";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Opened doors are closed and locked";

		public void Use()
		{
			Networker.Instance.DoorlockServerRPC();
		}

		public static void InvertDoors()
		{
			DoorLock[] array = Object.FindObjectsOfType<DoorLock>();
			foreach (DoorLock val in array)
			{
				val.OpenOrCloseDoor(GameNetworkManager.Instance.localPlayerController);
				val.LockDoor(30f);
			}
		}
	}
	internal class InvisibleEnemy : IEffect
	{
		public static ConfigEntry<bool> spider;

		public static ConfigEntry<bool> HoardingBug;

		public static ConfigEntry<bool> CoilHead;

		public static ConfigEntry<bool> Jester;

		public static ConfigEntry<bool> Centipede;

		public static ConfigEntry<bool> Bracken;

		public static ConfigEntry<bool> Barber;

		public static List<SpawnableEnemyWithRarity> spawnableEnemies = new List<SpawnableEnemyWithRarity>();

		public string Name => "Invisible Enemy";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Make sure you keep scanning for enemies!";

		public void Use()
		{
			spawnableEnemies.Clear();
			if (spider.Value && GetEnemies.Spider != null)
			{
				spawnableEnemies.Add(GetEnemies.Spider);
			}
			if (HoardingBug.Value && GetEnemies.HoardingBug != null)
			{
				spawnableEnemies.Add(GetEnemies.HoardingBug);
			}
			if (CoilHead.Value && GetEnemies.Coilhead != null)
			{
				spawnableEnemies.Add(GetEnemies.Coilhead);
			}
			if (Jester.Value && GetEnemies.Jester != null)
			{
				spawnableEnemies.Add(GetEnemies.Jester);
			}
			if (Centipede.Value && GetEnemies.Centipede != null)
			{
				spawnableEnemies.Add(GetEnemies.Centipede);
			}
			if (Bracken.Value && GetEnemies.Bracken != null)
			{
				spawnableEnemies.Add(GetEnemies.Bracken);
			}
			if (Barber.Value && GetEnemies.Barber != null)
			{
				spawnableEnemies.Add(GetEnemies.Barber);
			}
			int index = Random.Range(0, spawnableEnemies.Count);
			Misc.SpawnEnemyForced(spawnableEnemies[index], 1, isInside: true, isInvisible: true);
		}

		public static void Config()
		{
			spider = MysteryDice.BepInExConfig.Bind<bool>("InvisibleEnemy", "Spawn Spider", true, "Lets the invisible enemy event spawn an invisible spider");
			HoardingBug = MysteryDice.BepInExConfig.Bind<bool>("InvisibleEnemy", "Spawn Hoarding Bug", true, "Lets the invisible enemy event spawn an invisible Hoarding Bug");
			CoilHead = MysteryDice.BepInExConfig.Bind<bool>("InvisibleEnemy", "Spawn CoilHead", true, "Lets the invisible enemy event spawn an invisible CoilHead");
			Jester = MysteryDice.BepInExConfig.Bind<bool>("InvisibleEnemy", "Spawn Jester", true, "Lets the invisible enemy event spawn an invisible Jester");
			Centipede = MysteryDice.BepInExConfig.Bind<bool>("InvisibleEnemy", "Spawn Centipede", true, "Lets the invisible enemy event spawn an invisible Centipede");
			Bracken = MysteryDice.BepInExConfig.Bind<bool>("InvisibleEnemy", "Spawn Bracken", true, "Lets the invisible enemy event spawn an invisible Bracken");
			Barber = MysteryDice.BepInExConfig.Bind<bool>("InvisibleEnemy", "Spawn Barber", true, "Lets the invisible enemy event spawn an invisible Barber");
		}
	}
	internal class ItemDuplicator : IEffect
	{
		public string Name => "Item Duplicator";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Duplicates your inventory on the ground";

		public void Use()
		{
			Networker.Instance.ItemDuplicatorServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void duplicateItems(int userID)
		{
			//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_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_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)
			List<Item> list = new List<Item>();
			RoundManager instance = RoundManager.Instance;
			List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
			List<int> list3 = new List<int>();
			List<float> list4 = new List<float>();
			PlayerControllerB val = null;
			val = StartOfRound.Instance.allPlayerScripts[userID];
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GrabbableObject[] itemSlots = val.ItemSlots;
			foreach (GrabbableObject val2 in itemSlots)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					GameObject val3 = Object.Instantiate<GameObject>(val2.itemProperties.spawnPrefab, ((Component)val).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
					GrabbableObject component = val3.GetComponent<GrabbableObject>();
					((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
					component.fallTime = 0f;
					component.scrapValue = val2.scrapValue;
					component.itemProperties.weight = val2.itemProperties.weight;
					list3.Add(component.scrapValue);
					list4.Add(component.itemProperties.weight);
					NetworkObject component2 = val3.GetComponent<NetworkObject>();
					component2.Spawn(false);
					CullFactorySoftCompat.RefreshGrabbableObjectPosition(val3.GetComponent<GrabbableObject>());
					val3.GetComponent<GrabbableObject>().EnablePhysics(true);
					component.FallToGround(false, true, ((Component)val).transform.position);
					list2.Add(NetworkObjectReference.op_Implicit(component2));
				}
			}
			((MonoBehaviour)instance).StartCoroutine(ScrapJackpot.DelayedSync(instance, list2.ToArray(), list3.ToArray(), list4.ToArray()));
		}
	}
	internal class ItemSwap : IEffect
	{
		public string Name => "Item Swap";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Swaps the inventories of 2 players";

		public void Use()
		{
			Networker.Instance.ItemSwapServerRPC();
		}

		private static void SwapSlots(PlayerControllerB player, PlayerControllerB player2, int slot)
		{
			GrabbableObject val = player.ItemSlots[slot];
			GrabbableObject val2 = player2.ItemSlots[slot];
			player.ItemSlots[slot] = val2;
			player2.ItemSlots[slot] = val;
			if (((NetworkBehaviour)player).IsOwner)
			{
				HUDManager.Instance.itemSlotIcons[slot].sprite = val2.itemProperties.itemIcon;
				((Behaviour)HUDManager.Instance.itemSlotIcons[slot]).enabled = (Object)(object)val2 != (Object)null;
			}
			if (((NetworkBehaviour)player2).IsOwner)
			{
				HUDManager.Instance.itemSlotIcons[slot].sprite = val.itemProperties.itemIcon;
				((Behaviour)HUDManager.Instance.itemSlotIcons[slot]).enabled = (Object)(object)val != (Object)null;
			}
		}

		public static void itemSwap(int p1, int p2)
		{
			PlayerControllerB val = null;
			PlayerControllerB val2 = null;
			val = StartOfRound.Instance.allPlayerScripts[p1];
			val2 = StartOfRound.Instance.allPlayerScripts[p2];
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				Debug.LogError((object)"One or both players not found.");
				return;
			}
			for (int i = 0; i < val.ItemSlots.Length; i++)
			{
				SwapSlots(val, val2, i);
			}
		}
	}
	internal class JobAppPill : GalEffect, IEffect
	{
		public string Name => "Now Hiring";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Bad;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Are you looking for a job?";

		public void Use()
		{
			Networker.Instance.doRedPillStuffServerRPC(bald: false);
		}
	}
	internal class GlitchPill : IEffect
	{
		public string Name => "Bald and Angry";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "He is in denial";

		public void Use()
		{
			Networker.Instance.doRedPillStuffServerRPC(bald: true);
		}
	}
	internal class GlitchPillTwo : GalEffect, IEffect
	{
		public string Name => "Balder and Angrier";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Bad;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "He is in denial";

		public void Use()
		{
			Networker.Instance.doRedPillStuffServerRPC(bald: true);
		}
	}
	internal class GlitchPillThree : GalEffect, IEffect
	{
		public string Name => "Fishier and Angry";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Bad;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "He is in denial";

		public void Use()
		{
			Networker.Instance.doRedPillStuffServerRPC(bald: true, freebird: false, fish: true);
		}
	}
	public class RedPillChanger : MonoBehaviour
	{
		public GameObject RedPill;

		public Material RedPillMaterial;

		public bool isBald = false;

		public void Awake()
		{
			((MonoBehaviour)this).StartCoroutine(doStartStuff());
		}

		public IEnumerator doStartStuff()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)RedPill != (Object)null && (Object)(object)RedPillMaterial != (Object)null));
			Renderer renderer = ((Component)RedPill.transform.Find("Texture")).GetComponent<Renderer>();
			if (!Object.op_Implicit((Object)(object)renderer))
			{
				Debug.LogWarning((object)"RedPill has no Renderer!");
			}
			else
			{
				renderer.material = RedPillMaterial;
			}
		}
	}
	internal class JumpscareGlitch : IEffect
	{
		public string Name => "Jumpscare";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Prepare for a jumpscare";

		public void Use()
		{
			if ((Object)(object)MysteryDice.JumpscareScript != (Object)null)
			{
				int sync = MysteryDice.JumpscareScript.getIntNonScary();
				if (!MysteryDice.pussyMode.Value)
				{
					sync = MysteryDice.JumpscareScript.getIntScary();
				}
				((MonoBehaviour)Networker.Instance).StartCoroutine(Networker.Instance.DelayJumpscare(sync));
			}
			else
			{
				MysteryDice.CustomLogger.LogError((object)"JumpscareScript is null when trying to use a scare index!");
			}
		}
	}
	internal class Lasso : IEffect
	{
		public string Name => "Lasso";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Who are these men";

		public void Use()
		{
			int amount = Random.Range(5, 10);
			if (GetEnemies.Lasso != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Lasso, amount, isInside: true);
			}
		}
	}
	internal class LegendaryCatch : IEffect
	{
		public string Name => "Legendary Catch";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Go Catch a Legendary!";

		public void Use()
		{
			Networker.Instance.MasterballServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void SpawnMasterball(int playerID)
		{
			//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)
			List<Item> source = Resources.FindObjectsOfTypeAll<Item>().ToList();
			Item val = ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name.Equals("Masterball")));
			GameObject val2 = Object.Instantiate<GameObject>(val.spawnPrefab, ((Component)Misc.GetPlayerByUserID(playerID)).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
			val2.GetComponent<GrabbableObject>().fallTime = 0f;
			val2.GetComponent<NetworkObject>().Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(val2.GetComponent<GrabbableObject>());
			val2.GetComponent<GrabbableObject>().EnablePhysics(true);
		}
	}
	internal class LeverShake : IEffect
	{
		public static bool IsShaking = false;

		public static Vector3 InitialLevelTriggerLocalPosition = Vector3.zero;

		public static GameObject ShipLeverTrigger = null;

		public static GameObject ShipLever = null;

		public string Name => "Lever Shake";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Ship's lever starts moving!";

		public void Use()
		{
			Networker.Instance.LeverShakeServerRPC();
		}

		public static void ServerUse()
		{
		}

		public static void ClientsUse()
		{
			//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)
			IsShaking = true;
			ShipLeverTrigger = GameObject.Find("StartGameLever");
			ShipLever = GameObject.Find("HangarDoorLever");
			InitialLevelTriggerLocalPosition = ShipLeverTrigger.transform.localPosition;
		}

		public static void FixedUpdate()
		{
			//IL_0036: 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_0089: 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_00b1: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			if (!((Object)(object)ShipLeverTrigger == (Object)null) && IsShaking)
			{
				ShipLever.transform.position = ShipLeverTrigger.transform.position;
				ShipLeverTrigger.transform.localPosition = InitialLevelTriggerLocalPosition;
				float num = Mathf.PerlinNoise1D(Time.time) * 0.2f;
				float num2 = Mathf.PerlinNoise1D(Time.time * 0.5f) * 0.1f;
				Transform transform = ShipLeverTrigger.transform;
				transform.position += ShipLeverTrigger.transform.right * Mathf.Sin(Time.time) * 0.3f + ShipLeverTrigger.transform.up * (Mathf.Cos(Time.time * (2f + num)) * 0.5f + 1f) + ShipLeverTrigger.transform.forward * Mathf.Sin(Time.time * (1.2f + num2)) * 1.3f;
			}
		}
	}
	internal class LightBurden : IEffect
	{
		public string Name => "Light Burden";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Makes the weight of all items in your inventory a bit lighter";

		public void Use()
		{
			Networker.Instance.LightBurdenServerRPC();
		}

		public static void lessenWeight(int userID)
		{
			Misc.AdjustWeight(userID, 0.5f);
		}
	}
	internal class Lizard : GalEffect, IEffect
	{
		public static bool isRunning;

		public static double nextTime;

		public string Name => "Lizard";

		public EffectType RealOutcome => EffectType.Mixed;

		public EffectType NoGalOutcome => EffectType.GalOnly;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Lizard Lizard Lizard Lizard";

		public void Use()
		{
			Networker.Instance.DoLizardServerRPC();
		}

		public static void FixedUpdate()
		{
			if (isRunning)
			{
				if (nextTime <= 0.0)
				{
					nextTime = Random.Range(10f, 60f);
					DoLizardStuff();
				}
				nextTime -= Time.fixedDeltaTime;
			}
		}

		public static void DoLizardStuff()
		{
			//IL_0056: 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 (!((Object)(object)GalAI.Instances[0] == (Object)null))
			{
				DiceGalAI diceGalAI = GalAI.Instances[0] as DiceGalAI;
				if (!((Object)(object)diceGalAI == (Object)null))
				{
					Networker.Instance.PlaySoundFromGalServerRPC("Lizard");
					Networker.Instance.SpawnEnemyAtPosServerRPC("Tulip Snake", ((Component)diceGalAI).transform.position);
				}
			}
		}
	}
	internal class LizzieDog : IEffect
	{
		public string Name => "Lizzie`s Puppy";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You can pet that dog";

		public void Use()
		{
			if (GetEnemies.Dog != null)
			{
				Networker.Instance.PlaySoundServerRPC("Dawg");
				Networker.Instance.SpawnPetDogServerRPC();
			}
		}
	}
	internal class LongBertha : IEffect
	{
		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Long Bertha";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You might die";

		public void Use()
		{
			Networker.Instance.LongBerthaServerRPC();
		}

		public static void setExploded(ulong bertha, float time)
		{
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(bertha, out var value))
			{
				GameObject gameObject = ((Component)value).gameObject;
				Bertha componentInChildren = gameObject.GetComponentInChildren<Bertha>();
				componentInChildren.hasExploded = true;
				((MonoBehaviour)componentInChildren).StartCoroutine(InstantExplodingBerthas.DetonateDelay2(Misc.GetRandomAlivePlayer(), ((NetworkBehaviour)componentInChildren).NetworkObject.NetworkObjectId, time));
			}
		}

		public unsafe static void SpawnBerthaOutside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: 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_0229: 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_014c: 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_017f: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (InstantExplodingBerthas.GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.Bertha.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								val4.GetComponent<NetworkObject>().Spawn(true);
								num++;
								Bertha componentInChildren = val4.GetComponentInChildren<Bertha>();
								int num3 = Random.Range(30, 500);
								Networker.Instance.setExplodedServerRpc(((NetworkBehaviour)componentInChildren).NetworkObject.NetworkObjectId, num3);
								Networker.Instance.scaleOverTimeServerRpc(((NetworkBehaviour)componentInChildren).NetworkObject.NetworkObjectId, num3, 0.6f);
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}
	}
	internal class Lovers : IEffect
	{
		public string Name => "Lovers";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "2 people are now in love!";

		public void Use()
		{
			if (Misc.playerCount() == 1)
			{
				DieBehaviour.AllowedEffects[Random.Range(0, DieBehaviour.AllowedEffects.Count)].Use();
				return;
			}
			int num = 0;
			int num2 = 0;
			List<PlayerControllerB> source = new List<PlayerControllerB>(StartOfRound.Instance.allPlayerScripts);
			source = (from x in source
				where !x.isPlayerDead && ((Behaviour)x).isActiveAndEnabled && x.isPlayerControlled
				orderby Random.value
				select x).ToList();
			PlayerControllerB val = ((IEnumerable<PlayerControllerB>)source).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB p) => p.playerSteamId == 76561198291058317L));
			PlayerControllerB val2 = ((IEnumerable<PlayerControllerB>)source).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB p) => p.playerSteamId == 76561198984467725L));
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				num = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val);
				num2 = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val2);
			}
			else
			{
				num = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, source[0]);
				num2 = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, source[1]);
			}
			Networker.Instance.makeLoverServerRPC(num, num2);
		}

		public static void makeLovers(int p1, int p2)
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)(object)StartOfRound.Instance.allPlayerScripts[p1] || (Object)(object)localPlayerController == (Object)(object)StartOfRound.Instance.allPlayerScripts[p2])
			{
				loverScript loverScript2 = ((Component)localPlayerController).gameObject.AddComponent<loverScript>();
				loverScript2.me = localPlayerController;
				Misc.SafeTipMessage("Lovers!", "You are now in love with " + (loverScript2.lover = (((Object)(object)localPlayerController == (Object)(object)StartOfRound.Instance.allPlayerScripts[p1]) ? Misc.GetPlayerByUserID(p2) : Misc.GetPlayerByUserID(p1))).playerUsername);
			}
		}

		public static void removeLovers()
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			loverScript component = ((Component)localPlayerController).GetComponent<loverScript>();
			badLoverScripta component2 = ((Component)localPlayerController).GetComponent<badLoverScripta>();
			if ((Object)(object)component != (Object)null)
			{
				Misc.SafeTipMessage("Lovers", "You are no longer in love with " + component.lover.playerUsername);
				component.removeLover();
			}
			if ((Object)(object)component2 != (Object)null)
			{
				Misc.SafeTipMessage("Lovers", "You are no longer in love with an Enemy");
				component2.removeLover();
			}
		}
	}
	public class loverScript : MonoBehaviour
	{
		public PlayerControllerB me;

		public PlayerControllerB lover;

		public void Update()
		{
			//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)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (lover.isPlayerDead)
			{
				me.KillPlayer(Vector3.up, true, (CauseOfDeath)10, 0, default(Vector3), false);
				Object.Destroy((Object)(object)this);
			}
			if (me.isPlayerDead)
			{
				Object.Destroy((Object)(object)this);
			}
		}

		public void removeLover()
		{
			Object.Destroy((Object)(object)this);
		}
	}
	internal class MadScience : IEffect
	{
		public string Name => "Mad Science";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "IT'S ALIVE! ALIVE!!!!!!!!!!!!!!";

		public void Use()
		{
			Networker.Instance.doMadScienceServerRPC(1);
		}
	}
	internal class MadderScience : GalEffect, IEffect
	{
		public string Name => "Madder Science";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Awful;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "MUWAHAHAHAHA";

		public void Use()
		{
			Networker.Instance.doMadScienceServerRPC(3);
		}
	}
	internal class Maneaters : IEffect
	{
		public string Name => "Maneaters";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "A lot of maneaters spawned inside!";

		public void Use()
		{
			int amount = Random.Range(2, 7);
			if (GetEnemies.Maneater != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Maneater, amount, isInside: true);
			}
		}
	}
	internal class MantisShrimps : IEffect
	{
		public string Name => "Mantis Shrimps";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "They can punch the sun!";

		public void Use()
		{
			int amount = Random.Range(2, 4);
			if (GetEnemies.MantisShrimp != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.MantisShrimp, amount, isInside: true);
			}
		}
	}
	internal class ManyAds : IEffect
	{
		private static Queue<QueuedAd> adQueue = new Queue<QueuedAd>();

		private static bool adPlaying = false;

		public static List<string> neutralText = new List<string>();

		public static List<string> topText = new List<string>();

		public static List<string> bottomText = new List<string>();

		public string Name => "ManyAds";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Coming to you soon!";

		public void Use()
		{
			Networker.Instance.TriggerManyAdsServerRpc();
		}

		public static IEnumerator LoadRemoteTextLists()
		{
			topText.Clear();
			bottomText.Clear();
			neutralText.Clear();
			yield return LoadListFromURL(GetURLWithTimestamp("TopText.txt"), topText, InitializeTopText, "TopText");
			yield return LoadListFromURL(GetURLWithTimestamp("BottomText.txt"), bottomText, InitializeBottomText, "BottomText");
			yield return LoadListFromURL(GetURLWithTimestamp("NeutralText.txt"), neutralText, InitializeNeutralText, "NeutralText");
		}

		private static IEnumerator LoadListFromURL(string url, List<string> targetList, Action fallback, string name)
		{
			MysteryDice.ExtendedLogging("Loading List from url: " + url + " to target list: " + name, (LogLevel)16);
			UnityWebRequest www = UnityWebRequest.Get(url);
			try
			{
				www.useHttpContinue = false;
				www.SetRequestHeader("Cache-Control", "no-cache, no-store, must-revalidate");
				www.SetRequestHeader("Pragma", "no-cache");
				www.SetRequestHeader("Expires", "0");
				yield return www.SendWebRequest();
				if ((int)www.result != 1)
				{
					MysteryDice.CustomLogger.LogWarning((object)("Failed to load ad text from " + url + ": " + www.error));
					fallback?.Invoke();
					yield break;
				}
				targetList.Clear();
				string rawText = www.downloadHandler.text;
				MysteryDice.ExtendedLogging("[RawText] " + name + ": " + rawText, (LogLevel)16);
				string[] lines = rawText.Split(new char[2] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
				targetList.AddRange(from line in lines
					select line.Trim() into line
					where !string.IsNullOrWhiteSpace(line)
					select line);
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		private static string GetURLWithTimestamp(string fileName)
		{
			string arg = "https://slayer6409.github.io/Emergency-Dice-Updated/" + fileName;
			string text = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
			return $"{arg}?cachebust={Guid.NewGuid()}";
		}

		private static void InitializeTopText()
		{
			MysteryDice.ExtendedLogging("Fallback Top Text", (LogLevel)16);
			topText = new List<string>
			{
				"This fuckin thing", "top text", "Receding Hairline", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", "According to all known laws of aviation, there is no way a bee should be able to fly. Its wings are too small to get its fat little body off the ground. The bee, of course, flies anyway because bees don't care what humans think is impossible. Yellow, black. Yellow, black. Yellow, black. Yellow, black. Ooh, black and yellow! Let's shake it up a little. Barry! Breakfast is ready! Ooming! Hang on a second. Hello? - Barry? - Adam? - Oan you believe this is happening? - I can't. I'll pick you up. Looking sharp. Use the stairs. Your father paid good money for those. Sorry. I'm excited. Here's the graduate. We're very proud of you, son. A perfect report card, all B's. Very proud. Ma! I got a thing going here. - You got lint on your fuzz. - Ow! That's me! - Wave to us! We'll be in row 118,000. - Bye! Barry, I told you, stop flying in the house! - Hey, Adam. - Hey, Barry. - Is that fuzz gel? - A little. Special day, graduation. Never thought I'd make it. Three days grade school, three days high school. Those were awkward. Three days college. I'm glad I took a day and hitchhiked around the hive. You did come back different.", "Open Gale", "I scream", "My cat", "My dog", "Zeekerss",
				"Hot gals", "Sapsucker", "Ogopogo", "Dice", "Jimothy", "Scrap-E", "Biodiversity", "Surfaced", "Code rebirth", "Hi I'm Chris Hansen"
			};
		}

		private static void InitializeBottomText()
		{
			MysteryDice.ExtendedLogging("Fallback Bottom Text", (LogLevel)16);
			bottomText = new List<string>
			{
				"bottom text", "I wonder whose?", "Take a bath", "Import local mod", "Is a milf", "In your area", "You", "Buy 1 get 1", "Ive seen better", "sucks",
				"is cancelled", "The least of your concern", "is entertaining", "I wish they were real", "Not safe for work", "Happy birthday!", "Most likely to die next", "It burns when I pee", "Wheres the beef", "Spin spin spin",
				"is dead"
			};
		}

		private static void InitializeNeutralText()
		{
			MysteryDice.ExtendedLogging("Fallback Neutral Text", (LogLevel)16);
			neutralText = new List<string>
			{
				"Breaking News!", "Fuck", "Heheheheheheh", "Not the best", "?????????????????????", "What the fuck?", "Hehehehehehehe", ">:D", "Wut", "Ewwwww",
				"Happy Birthday", "Mu Mu Mu", "Whose child is this?", "Oh no", "RUN", "I hate it", "Go away", "Got ran over by a car", "Go Scarab", "Whatever",
				"Sussy", "Nice wig", "Smash.", "Skill Issue", "Someone clip that", "is Bald", "is Stinky", "is Short", "Glitch is Bald", "Mu is Bald",
				"Cross is Stinky", "Beef is Short", "The Short, Bald, and Stinky", "wi wi wi", "", "There is a config you should change :D"
			};
		}

		public static void logAll()
		{
			MysteryDice.ExtendedLogging("Logging All", (LogLevel)16);
			foreach (string item in topText)
			{
				MysteryDice.ExtendedLogging("Top " + item, (LogLevel)16);
			}
			foreach (string item2 in bottomText)
			{
				MysteryDice.ExtendedLogging("Bottom " + item2, (LogLevel)16);
			}
			foreach (string item3 in neutralText)
			{
				MysteryDice.ExtendedLogging("Neutral " + item3, (LogLevel)16);
			}
		}

		public static string getTopText()
		{
			logAll();
			List<string> list = new List<string>(topText);
			list.AddRange((from p in StartOfRound.Instance.allPlayerScripts
				where p.isPlayerControlled || p.isPlayerDead
				select p.playerUsername).ToList());
			list.AddRange(neutralText);
			return list[Random.Range(0, list.Count)];
		}

		public static string getBottomText()
		{
			List<string> list = new List<string>(bottomText);
			list.AddRange((from p in StartOfRound.Instance.allPlayerScripts
				where p.isPlayerControlled || p.isPlayerDead
				select p.playerUsername).ToList());
			list.AddRange(neutralText);
			return list[Random.Range(0, list.Count)];
		}

		public static void QueueAd(bool isTool, string name, string top, string bottom, bool isObject = false, GameObject prefab = null)
		{
			adQueue.Enqueue(new QueuedAd(isTool, name, top, bottom, isObject, prefab));
			if (!adPlaying)
			{
				((MonoBehaviour)HUDManager.Instance).StartCoroutine(PlayAdQueue());
			}
		}

		private static IEnumerator PlayAdQueue()
		{
			adPlaying = true;
			while (adQueue.Count > 0)
			{
				QueuedAd ad = adQueue.Dequeue();
				if (ad.isTool)
				{
					showItemAd(ad.name, ad.topText, ad.bottomText);
				}
				else if (!ad.isObject)
				{
					showUnlockableAd(ad.name, ad.topText, ad.bottomText);
				}
				else
				{
					showPrefabAd(ad.prefabObject, ad.topText, ad.bottomText);
				}
				yield return (object)new WaitForSeconds(14.2f);
			}
			adPlaying = false;
		}

		public static void showPrefabAd(GameObject prefab, string top, string bottom)
		{
			CreatePrefabAdModel(prefab);
			HUDManager.Instance.BeginDisplayAd(top, bottom);
		}

		public static void showItemAd(string itemName, string top, string bottom)
		{
			Item val = StartOfRound.Instance.allItemsList.itemsList.Find((Item x) => x.itemName == itemName);
			if ((Object)(object)val == (Object)null)
			{
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogWarning((object)"Show Item Ad: Item is Null");
				}
			}
			else if ((Object)(object)val.spawnPrefab == (Object)null)
			{
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogWarning((object)"Show Item Ad: Item spawn prefab is null");
				}
			}
			else
			{
				HUDManager.Instance.CreateToolAdModel(-100, val);
				doAdStuff(top, bottom);
			}
		}

		public static void doAdStuff(string top, string bottom)
		{
			MysteryDice.ExtendedLogging("Do Ad Stuff: " + top + " " + bottom, (LogLevel)16);
			HUDManager instance = HUDManager.Instance;
			((TMP_Text)instance.advertTopText).text = top;
			((TMP_Text)instance.advertBottomText).text = bottom;
			if (instance.displayAdCoroutine != null)
			{
				((MonoBehaviour)instance).StopCoroutine(instance.displayAdCoroutine);
			}
			instance.displayAdCoroutine = ((MonoBehaviour)instance).StartCoroutine(instance.displayAd());
		}

		public static void CreatePrefabAdModel(GameObject prefab)
		{
			//IL_0096: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(prefab, HUDManager.Instance.advertItemParent);
			MonoBehaviour[] components = prefab.GetComponents<MonoBehaviour>();
			foreach (MonoBehaviour val2 in components)
			{
				Object.Destroy((Object)(object)val2);
			}
			NetworkObject component = val.GetComponent<NetworkObject>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			GrabbableObject component2 = val.GetComponent<GrabbableObject>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
			Collider component3 = val.GetComponent<Collider>();
			if ((Object)(object)component3 != (Object)null)
			{
				Object.Destroy((Object)(object)component3);
			}
			val.transform.localPosition = Vector3.zero;
			val.transform.localScale = val.transform.localScale * 155f;
			val.transform.rotation = Quaternion.identity;
			Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>();
			SetLayerRecursively(val, 23);
			val.SetActive(true);
		}

		public static void SetLayerRecursively(GameObject obj, int layer)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			obj.layer = layer;
			foreach (Transform item in obj.transform)
			{
				Transform val = item;
				SetLayerRecursively(((Component)val).gameObject, layer);
			}
		}

		public static void showUnlockableAd(string unlockableName, string top, string bottom)
		{
			UnlockableItem val = StartOfRound.Instance.unlockablesList.unlockables.Find((UnlockableItem x) => x.unlockableName == unlockableName);
			if (val == null)
			{
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogWarning((object)"Show Unlockable Ad: Unlockable is Null. Huh");
				}
			}
			else if ((Object)(object)val.prefabObject == (Object)null)
			{
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogWarning((object)"Show Unlockable Ad: Unlockable prefabObject is Null. Huh");
				}
			}
			else
			{
				HUDManager.Instance.CreateFurnitureAdModel(val);
				doAdStuff(top, bottom);
			}
		}

		public static void showRandomAd()
		{
			string top = getTopText();
			string bottom = getBottomText();
			if (Random.value > 0.5f)
			{
				List<Item> list = StartOfRound.Instance.allItemsList.itemsList.Where((Item x) => (Object)(object)x != (Object)null && (Object)(object)x.spawnPrefab != (Object)null).ToList();
				int index = Random.Range(0, list.Count);
				Item val = list[index];
				Networker.Instance.AdServerRPC(item: true, val.itemName, top, bottom);
			}
			else
			{
				List<UnlockableItem> list2 = StartOfRound.Instance.unlockablesList.unlockables.Where((UnlockableItem x) => (Object)(object)x.prefabObject != (Object)null).ToList();
				UnlockableItem val2 = list2[Random.Range(0, list2.Count)];
				Networker.Instance.AdServerRPC(item: false, val2.unlockableName, top, bottom);
			}
		}
	}
	public class QueuedAd
	{
		public bool isTool;

		public bool isObject;

		public GameObject prefabObject;

		public string name;

		public string topText;

		public string bottomText;

		public QueuedAd(bool isTool, string name, string topText, string bottomText, bool isObject = false, GameObject prefabObject = null)
		{
			this.isTool = isTool;
			this.isObject = isObject;
			this.prefabObject = prefabObject;
			this.name = name;
			this.topText = topText;
			this.bottomText = bottomText;
		}
	}
	internal class Martyrdom : IEffect
	{
		public static bool doMinesDrop;

		public string Name => "Martyrdom";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Players Drop bombs on death now";

		public void Use()
		{
			Networker.Instance.MartyrdomServerRPC();
		}
	}
	internal class MerryChristmas : IEffect
	{
		public string Name => "Christmas";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Merry Christmas!";

		public void Use()
		{
			//IL_002f: 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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(3, 9), "Gift");
		}
	}
	internal class Meteors : IEffect
	{
		public static bool isRunning;

		public string Name => "Meteors";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "I hope you like space rocks";

		public void Use()
		{
			Networker.Instance.SpawnMeteorsServerRPC();
		}
	}
	internal class MicroTrap : IEffect
	{
		public static int MaxMinesToSpawn = 5;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Micro Trap";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "It so Smol";

		public void Use()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			trap[] allTraps = Misc.getAllTraps();
			Networker.Instance.CustomScaledTrapServerRPC(MaxMinesToSpawn, allTraps[Random.Range(0, allTraps.Length)].name, Random.value > 0.5f, new Vector3(0.3f, 0.3f, 0.3f));
		}
	}
	internal class MicrowaveBertha : IEffect
	{
		public string Name => "Microwavable Bertha";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "MMMMMMMMMMMMMM BOOM";

		public void Use()
		{
			Networker.Instance.MicrowaveBerthaServerRPC(Random.Range(1, 4));
		}

		public static void spawnMicrowaveBertha(int num)
		{
			//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_0087: 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_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_00af: 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_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_00f4: 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)
			for (int i = 0; i < num; i++)
			{
				SpawnableMapObject microwave = GetEnemies.Microwave;
				SpawnableMapObject bertha = GetEnemies.Bertha;
				RoundManager instance = RoundManager.Instance;
				Random random = new Random(StartOfRound.Instance.randomMapSeed);
				GameObject[] source = GameObject.FindGameObjectsWithTag("OutsideAINode");
				source = source.OrderBy((GameObject x) => Vector3.Distance(x.transform.position, Vector3.zero)).ToArray();
				Vector3 position = instance.outsideAINodes[Random.Range(0, instance.outsideAINodes.Length)].transform.position;
				position = instance.GetRandomNavMeshPositionInBoxPredictable(position, 30f, default(NavMeshHit), random, -1, 1f) + Vector3.up;
				GameObject val = Object.Instantiate<GameObject>(microwave.prefabToSpawn, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				val.GetComponent<NetworkObject>().Spawn(true);
				GameObject val2 = Object.Instantiate<GameObject>(bertha.prefabToSpawn, val.transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
				val.GetComponent<NetworkObject>().Spawn(true);
				val2.transform.SetParent(val.transform);
			}
		}
	}
	internal class Microwave : IEffect
	{
		public static int MaxMinesToSpawn = 7;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Microwave";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Who put microwaves outside?";

		public void Use()
		{
			Networker.Instance.CustomTrapServerRPC(MaxMinesToSpawn, ((Object)GetEnemies.Microwave.prefabToSpawn).name, inside: false);
		}
	}
	internal class MineExploder : IEffect
	{
		public string Name => "Mine Exploder";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Explode all mines";

		public void Use()
		{
			Networker.Instance.turretMineExploderServerRPC(turret: false);
		}

		public static void explodeAllMines()
		{
			Landmine[] array = Object.FindObjectsByType<Landmine>((FindObjectsSortMode)0);
			Landmine[] array2 = array;
			foreach (Landmine val in array2)
			{
				val.ExplodeMineServerRpc();
			}
		}
	}
	internal class TurretExploder : GalEffect, IEffect
	{
		public string Name => "Turret Exploder";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Explode all turrets";

		public void Use()
		{
			Networker.Instance.turretMineExploderServerRPC(turret: true);
		}

		public static void explodeAllMines()
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			Turret[] array = Object.FindObjectsByType<Turret>((FindObjectsSortMode)0);
			Turret[] array2 = array;
			foreach (Turret val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Vector3 position = ((Component)val).transform.position;
				Landmine.SpawnExplosion(position, true, 0f, 0f, 0, 2f, (GameObject)null, false);
				if ((Object)(object)val != (Object)null)
				{
					NetworkObject component = ((Component)val).GetComponent<NetworkObject>();
					if ((Object)(object)component != (Object)null && component.IsSpawned)
					{
						component.Despawn(true);
					}
				}
			}
		}
	}
	internal class MineHardPlace : IEffect
	{
		public string Name => "Mine and a Hard Place";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You can't go anywhere now";

		public void Use()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Networker.Instance.SpawnSurroundedTrapServerRPC(((Object)GetEnemies.Bertha.prefabToSpawn).name, 8, 7, doSize: true, new Vector3(1.25f, 2f, 1.25f));
		}
	}
	internal class MineOverflow : IEffect
	{
		public static int MaxMinesToSpawn = 30;

		public string Name => "Mine overflow";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "More mines spawned inside!";

		public void Use()
		{
			Networker.Instance.MineOverflowServerRPC();
		}

		public static void SpawnMoreMines(int amount)
		{
			//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_0044: 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_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_005c: 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_0082: 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_00b4: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			int num = 0;
			GameObject[] insideAINodes = RoundManager.Instance.insideAINodes;
			foreach (GameObject val in insideAINodes)
			{
				Vector3 position = val.transform.position;
				if (num > amount)
				{
					break;
				}
				Vector3 randomNavMeshPositionInRadiusSpherical = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(position, 10f, default(NavMeshHit));
				if (!(GetShortestDistanceSqr(randomNavMeshPositionInRadiusSpherical, list) < 1f))
				{
					GameObject val2 = Object.Instantiate<GameObject>(GetEnemies.SpawnableLandmine.prefabToSpawn, randomNavMeshPositionInRadiusSpherical, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
					list.Add(randomNavMeshPositionInRadiusSpherical);
					val2.transform.eulerAngles = new Vector3(val2.transform.eulerAngles.x, (float)Random.Range(0, 360), val2.transform.eulerAngles.z);
					val2.GetComponent<NetworkObject>().Spawn(true);
					num++;
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class MineOverflowOutside : IEffect
	{
		public static int MaxMinesToSpawn = 80;

		public string Name => "Mine overflow outside";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Mines spawned outside!";

		public void Use()
		{
			Networker.Instance.MineOverflowOutsideServerRPC();
		}

		public static void SpawnMoreMinesOutside()
		{
			//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_0063: 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_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_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_00a8: 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_00da: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			GameObject[] outsideAINodes = RoundManager.Instance.outsideAINodes;
			foreach (GameObject val in outsideAINodes)
			{
				Vector3 position = val.transform.position;
				for (int j = 0; j < 8; j++)
				{
					if (num > MaxMinesToSpawn)
					{
						return;
					}
					Vector3 randomNavMeshPositionInBoxPredictable = RoundManager.Instance.GetRandomNavMeshPositionInBoxPredictable(position, 15f, RoundManager.Instance.navHit, random, -1, 1f);
					if (!(MineOverflow.GetShortestDistanceSqr(randomNavMeshPositionInBoxPredictable, list) < 1f))
					{
						GameObject val2 = Object.Instantiate<GameObject>(GetEnemies.SpawnableLandmine.prefabToSpawn, randomNavMeshPositionInBoxPredictable, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
						list.Add(randomNavMeshPositionInBoxPredictable);
						val2.transform.eulerAngles = new Vector3(val2.transform.eulerAngles.x, (float)Random.Range(0, 360), val2.transform.eulerAngles.z);
						val2.GetComponent<NetworkObject>().Spawn(true);
						num++;
					}
				}
			}
		}
	}
	public interface MythzanEffect : IEffect
	{
	}
	internal class ModifyPitch : IEffect
	{
		private const float PitchSwitchTime = 0.1f;

		private static float PitchSwitchTimer;

		public static bool FluctuatePitch;

		private static float CumulativeRandomFreq;

		public string Name => "Speech jammer";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Good luck communicating";

		public void Use()
		{
			Networker.Instance.ModifyPitchNotifyServerRPC();
		}

		public static void ResetPitch()
		{
			FluctuatePitch = false;
			foreach (PlayerControllerB item in StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB x) => x.isPlayerControlled))
			{
				if (!((Object)(object)item.currentVoiceChatAudioSource == (Object)null))
				{
					item.currentVoiceChatAudioSource.pitch = 1f;
				}
			}
		}

		public static void PitchFluctuate()
		{
			if (!FluctuatePitch)
			{
				return;
			}
			CumulativeRandomFreq += Random.Range(-0.8f, 0.8f) * Time.deltaTime;
			CumulativeRandomFreq = Mathf.Clamp(CumulativeRandomFreq, -1f, 1f);
			PitchSwitchTimer -= Time.deltaTime;
			if (!(PitchSwitchTimer <= 0f))
			{
				return;
			}
			try
			{
				PitchSwitchTimer = 0.1f;
				foreach (PlayerControllerB item in StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB x) => x.isPlayerControlled))
				{
					if (!((Object)(object)item.currentVoiceChatAudioSource == (Object)null))
					{
						item.currentVoiceChatAudioSource.pitch = Misc.Map(Mathf.Sin((2f + CumulativeRandomFreq) * MathF.PI * Time.time), -1f, 1f, 0.6f, 1.4f);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogWarning((object)("There's a problem with the pitch fluctuate effect: " + ex.Message));
			}
		}
	}
	internal class MoreLives : GalEffect, IEffect
	{
		public string Name => "Extra Lives";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Everyone Gets an Extra Life";

		public void Use()
		{
			Networker.Instance.AddLifeAllServerRPC();
		}
	}
	internal class AddLife : IEffect
	{
		public string Name => "Add One Life";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "You get an Extra Life";

		public void Use()
		{
			Networker.Instance.AddLifeServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}
	}
	public class playerLifeController : MonoBehaviour
	{
		public int livesRemaining = 0;

		public PlayerControllerB player;

		public bool currentlyRunning = false;

		public void addLife()
		{
			livesRemaining++;
			Networker.Instance.SendMessageServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), "Extra Life!", "You got an extra life! You now have " + livesRemaining + " lives remaining.");
		}

		private void FixedUpdate()
		{
			if (player.isPlayerDead && !currentlyRunning && livesRemaining > 0)
			{
				currentlyRunning = true;
				((MonoBehaviour)this).StartCoroutine(wait());
			}
		}

		public IEnumerator wait()
		{
			livesRemaining--;
			yield return (object)new WaitForSeconds(0.25f);
			Networker.Instance.RevivePlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), StartOfRound.Instance.middleOfShipNode.position);
			Networker.Instance.SendMessageServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), "Revived!", "You used an extra life! You now have " + livesRemaining + " lives remaining.");
			((MonoBehaviour)this).StartCoroutine(wait2());
		}

		public IEnumerator wait2()
		{
			yield return (object)new WaitForSeconds(0.25f);
			currentlyRunning = false;
		}
	}
	internal class MovingBeartraps : IEffect
	{
		private static List<GameObject> bearTraps = new List<GameObject>();

		public string Name => "Roomba Beartraps";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Roomba Beartraps?";

		public void Use()
		{
			Networker.Instance.MovingBeartrapsServerRPC();
		}

		public static IEnumerator fixSpiney(GameObject obj)
		{
			yield return (object)new WaitForSeconds(0.1f);
			LaserTurret laser = obj.GetComponentInChildren<LaserTurret>();
			if ((Object)(object)laser != (Object)null)
			{
				laser.rotationSpeed = 800f;
				yield break;
			}
			laser = obj.GetComponent<LaserTurret>();
			if ((Object)(object)laser != (Object)null)
			{
				laser.rotationSpeed = 800f;
			}
		}
	}
	internal class MovingSeaTraps : IEffect
	{
		public string Name => "Unchained";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Who cut their chain??";

		public void Use()
		{
			Networker.Instance.MovingSeatrapsServerRPC();
		}
	}
	internal class MovingCrane : GalEffect, IEffect
	{
		public string Name => "Moving Crane";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.Bad;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Dear Lord what have I done";

		public void Use()
		{
			Networker.Instance.doMovingCraneServerRPC();
		}
	}
	internal class MovingCrates : IEffect
	{
		public string Name => "Moving Crates";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "They ship themselves";

		public void Use()
		{
			Networker.Instance.MovingCratesServerRPC();
		}

		public static IEnumerator MakeMovingCrates()
		{
			IEnumerable<trap> crates = from x in Misc.getAllTraps()
				where x.name.Contains("Crate") || x.name.Contains("Safe")
				select x;
			RoundManager RM = RoundManager.Instance;
			int crateAmount = Random.Range(2, 6);
			yield return (object)new WaitForSeconds(2f);
			for (int i = 0; i < crateAmount; i++)
			{
				trap trapToSpawn = (from _ in crates.ToList()
					orderby Random.value
					select _).First();
				Vector3 position = (((double)Random.value > 0.5) ? RM.outsideAINodes[Random.Range(0, RM.outsideAINodes.Length)].transform.position : RM.insideAINodes[Random.Range(0, RM.outsideAINodes.Length)].transform.position);
				GameObject agent = Object.Instantiate<GameObject>(MysteryDice.AgentObjectPrefab, position, Quaternion.Euler(0f, 0f, 0f));
				GameObject trap = Object.Instantiate<GameObject>(trapToSpawn.prefab, position, Quaternion.Euler(0f, 0f, 0f));
				NetworkObject netobj = trap.GetComponent<NetworkObject>();
				netobj.Spawn(true);
				agent.GetComponent<NetworkObject>().Spawn(true);
				SmartAgentNavigator smartAgentNavigator = agent.GetComponent<SmartAgentNavigator>();
				MakeMove mm = trap.AddComponent<MakeMove>();
				trap.transform.SetParent(agent.transform);
				trap.transform.localPosition = new Vector3(0f, 0.5f, 0f);
				trap.transform.localRotation = Quaternion.identity;
				mm.Initialize(smartAgentNavigator);
				((Behaviour)mm).enabled = true;
				SceneManager.MoveGameObjectToScene(agent, RoundManager.Instance.mapPropsContainer.scene);
				if (trapToSpawn.name.Contains("Mimic"))
				{
					ItemCrate ic = trap.GetComponent<ItemCrate>();
					ic.health = 1;
					ic.digProgress = 2f;
					if ((Object)(object)ic.pickable != (Object)null)
					{
						ic.pickable.IsLocked = false;
					}
					Networker.Instance.CrateOpenServerRPC(netobj.NetworkObjectId);
				}
			}
		}

		public static IEnumerator crateOpener(ulong crateId)
		{
			yield return (object)new WaitForSeconds(2f);
			if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(crateId, out var networkObj))
			{
				GameObject trap = ((Component)networkObj).gameObject;
				ItemCrate ic = trap.GetComponent<ItemCrate>();
				ic.OpenCrate();
			}
		}
	}
	internal class MovingFans : IEffect
	{
		public string Name => "Moving Fans";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Fan-tastic";

		public void Use()
		{
			Networker.Instance.MovingFansServerRPC();
		}

		public static IEnumerator WaitForTrapInit(string trapName, bool follower = false, int followerID = 0)
		{
			yield return (object)new WaitForSeconds(5f);
			if (!((NetworkBehaviour)RoundManager.Instance).IsHost)
			{
				yield break;
			}
			foreach (GameObject trap in from c in Object.FindObjectsOfType<GameObject>()
				where ((Object)c).name.ToUpper().Contains(trapName.ToUpper())
				select c)
			{
				NetworkObject no = trap.GetComponent<NetworkObject>();
				if ((Object)(object)no == (Object)null || ((Object)((Component)no).gameObject).name.ToUpper().Contains("GAL") || ((Object)((Component)no).gameObject).name.ToUpper().Contains("CHARGER"))
				{
					continue;
				}
				if (!Object.op_Implicit((Object)(object)trap))
				{
					MysteryDice.CustomLogger.LogWarning((object)"Trap is null.");
					continue;
				}
				Transform trapParent = trap.transform.parent;
				if ((Object)(object)trapParent != (Object)null && ((trapName.ToUpper() == "SEAMINE" && ((Object)trapParent).name.ToUpper().Contains("BERTHA")) || ((Object)trapParent).name.ToUpper().Contains(trapName.ToUpper())))
				{
					continue;
				}
				GameObject targetObject = trap.gameObject;
				if ((Object)(object)targetObject.GetComponent<MakeMove>() == (Object)null)
				{
					GameObject agent = Object.Instantiate<GameObject>(MysteryDice.AgentObjectPrefab, targetObject.transform.position, Quaternion.Euler(0f, 0f, 0f));
					if (trapName == "SeaMine")
					{
						agent.transform.localScale = new Vector3(0.4573873f, 0.4573873f, 0.4573873f);
					}
					SmartAgentNavigator smartAgentNavigator = agent.GetComponent<SmartAgentNavigator>();
					MakeMove mm = targetObject.AddComponent<MakeMove>();
					if (follower)
					{
						mm.follows = Misc.GetPlayerByUserID(followerID);
					}
					agent.GetComponent<NetworkObject>().Spawn(true);
					trap.transform.SetParent(agent.transform);
					targetObject.transform.localPosition = Vector3.zero;
					trap.transform.localPosition = new Vector3(0f, 0.2f, 0f);
					targetObject.transform.localRotation = Quaternion.identity;
					mm.Initialize(smartAgentNavigator);
					((Behaviour)mm).enabled = true;
					SceneManager.MoveGameObjectToScene(agent, RoundManager.Instance.mapPropsContainer.scene);
				}
			}
		}

		public static IEnumerator freebirdTrapSpawn(string trapName, bool random = false)
		{
			List<trap> allTraps = (from x in Misc.getAllTraps()
				group x by x.name into g
				select g.First()).ToList();
			trap trapToSpawn = ((!random) ? allTraps.Find((trap x) => x.name == trapName) : allTraps.OrderBy((trap _) => Random.value).First());
			RoundManager RM = RoundManager.Instance;
			yield return (object)new WaitForSeconds(2f);
			Vector3 position = (((double)Random.value > 0.5) ? RM.outsideAINodes[Random.Range(0, RM.outsideAINodes.Length)].transform.position : RM.insideAINodes[Random.Range(0, RM.outsideAINodes.Length)].transform.position);
			GameObject agent = Object.Instantiate<GameObject>(MysteryDice.AgentObjectPrefab, position, Quaternion.Euler(0f, 0f, 0f));
			GameObject trap = Object.Instantiate<GameObject>(trapToSpawn.prefab, position, Quaternion.Euler(0f, 0f, 0f));
			trap.GetComponent<NetworkObject>().Spawn(true);
			agent.GetComponent<NetworkObject>().Spawn(true);
			SmartAgentNavigator smartAgentNavigator = agent.GetComponent<SmartAgentNavigator>();
			MakeMove mm = trap.AddComponent<MakeMove>();
			trap.transform.SetParent(agent.transform);
			trap.transform.localPosition = new Vector3(0f, 0.2f, 0f);
			trap.transform.localRotation = Quaternion.identity;
			mm.Initialize(smartAgentNavigator);
			((Behaviour)mm).enabled = true;
			SceneManager.MoveGameObjectToScene(agent, RoundManager.Instance.mapPropsContainer.scene);
			if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				Networker.Instance.FreebirdTrapClientRPC(agent.GetComponent<NetworkObject>().NetworkObjectId);
			}
		}
	}
	public class MakeMove : MonoBehaviour
	{
		private float _pathTimer = 0f;

		private GameObject[] outsidePoints;

		private GameObject[] InsidePoints;

		public SmartAgentNavigator agent;

		public bool currently = false;

		[CanBeNull]
		public PlayerControllerB follows = null;

		private Vector3 _currentTargetPosition = Vector3.zero;

		private bool _currentIsInside = false;

		private void Awake()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			outsidePoints = RoundManager.Instance.outsideAINodes;
			InsidePoints = RoundManager.Instance.insideAINodes;
			if (outsidePoints.Length == 0 || InsidePoints.Length == 0)
			{
				MysteryDice.CustomLogger.LogError((object)"AINodes not found. Ensure they are tagged correctly.");
			}
			SceneManager.MoveGameObjectToScene(((Component)this).gameObject, RoundManager.Instance.mapPropsContainer.scene);
		}

		public void Initialize(SmartAgentNavigator assignedAgent)
		{
			agent = assignedAgent;
			agent.SetAllValues(isOutside: true);
			agent.OnUseEntranceTeleport.AddListener((UnityAction<bool>)OnUseEntranceTeleport);
			agent.OnEnableOrDisableAgent.AddListener((UnityAction<bool>)OnEnableOrDisableAgent);
		}

		public void OnEnableOrDisableAgent(bool agentEnabled)
		{
		}

		public void OnUseEntranceTeleport(bool setOutside)
		{
		}

		public void FixedUpdate()
		{
			//IL_0217: 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_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_018d: 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_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_01ce: 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_011f: 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_0158: 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_0165: 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)
			if (!((NetworkBehaviour)Networker.Instance).IsServer)
			{
				return;
			}
			if ((Object)(object)follows != (Object)null && (Object)(object)agent != (Object)null)
			{
				agent.AdjustSpeedBasedOnDistance(1.5f);
				if (StartOfRound.Instance.inShipPhase)
				{
					follows = null;
				}
			}
			_pathTimer -= Time.fixedDeltaTime;
			if (_pathTimer <= 0f)
			{
				if ((Object)(object)follows != (Object)null)
				{
					_currentTargetPosition = ((Component)follows).transform.position;
					_currentIsInside = follows.isInsideFactory;
				}
				else
				{
					bool flag = false;
					Vector3 zero = Vector3.zero;
					_pathTimer = Random.Range(5f, 25f);
					float value = Random.value;
					if (value > 0.5f)
					{
						flag = false;
						zero = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(outsidePoints[Random.Range(0, outsidePoints.Length)].transform.position + new Vector3(Random.Range(-10f, 10f), 0f, Random.Range(-10f, 10f)), 10f, default(NavMeshHit));
					}
					else
					{
						flag = true;
						zero = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(InsidePoints[Random.Range(0, InsidePoints.Length)].transform.position + new Vector3(Random.Range(-10f, 10f), 0f, Random.Range(-10f, 10f)), 10f, default(NavMeshHit));
					}
					if ((Object)(object)agent == (Object)null)
					{
						return;
					}
					_currentTargetPosition = zero;
					_currentIsInside = flag;
				}
			}
			if ((Object)(object)agent != (Object)null)
			{
				agent.DoPathingToDestination(_currentTargetPosition);
			}
		}
	}
	internal class MovingLandmines : IEffect
	{
		public string Name => "Moving Landmines";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Landmines are now moving!";

		public void Use()
		{
			Networker.Instance.MovingMinesInitServerRPC();
		}
	}
	internal class MovingTPTraps : IEffect
	{
		public string Name => "Moving Teleporter Traps";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "The Teleporters are now Roombas";

		public void Use()
		{
			Networker.Instance.MovingTrapsInitServerRPC();
		}
	}
	internal class Healers : IEffect
	{
		public string Name => "Maybe Healers";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "They can heal...";

		public void Use()
		{
			//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)
			PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
			Networker.Instance.setHealthServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomAlivePlayer), 20);
			Networker.Instance.SpawnSurroundedSelectServerRPC("Nancy", Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomAlivePlayer), 4, 2);
		}
	}
	internal class NavMeshPenalty : IEffect
	{
		public string Name => "NavMeshPenalty";

		public EffectType Outcome => EffectType.Penalty;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You shouldn't have done that";

		public void Use()
		{
			Networker.Instance.doPenaltyServerRPC(10);
		}

		public static void doPenalty(int amount)
		{
			List<SpawnableEnemyWithRarity> list = StartOfRound.Instance.currentLevel.Enemies.Union(StartOfRound.Instance.currentLevel.OutsideEnemies).Union(StartOfRound.Instance.currentLevel.DaytimeEnemies).ToList();
			List<SpawnableEnemyWithRarity> list2 = new List<SpawnableEnemyWithRarity>();
			for (int i = 0; i < amount; i++)
			{
				SpawnableEnemyWithRarity item = list[Random.Range(0, list.Count)];
				list2.Add(item);
			}
			foreach (SpawnableEnemyWithRarity item2 in list2)
			{
				Misc.SpawnEnemyForced(item2, 1, isInside: false);
			}
		}
	}
	internal class NutsBaby : IEffect
	{
		public string Name => "NDB";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Non-deductible Breakfast";

		public void Use()
		{
			if (GetEnemies.Maneater != null)
			{
				Networker.Instance.SpawnDongServerRPC();
			}
		}
	}
	public class ManeaterPatchThing : MonoBehaviour
	{
		private CaveDwellerAI _instance;

		public void Update()
		{
			if ((Object)(object)_instance == (Object)null)
			{
				((Component)this).gameObject.TryGetComponent<CaveDwellerAI>(ref _instance);
			}
			else
			{
				_instance.growthMeter = 0f;
			}
		}
	}
	internal class NeckBreak : IEffect
	{
		public static int IsNeckBroken = 0;

		public static float breakTime = 30f;

		public static bool isTimerRunning = false;

		public string Name => "Neck Break";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Your neck is broken!";

		public void Use()
		{
			Networker.Instance.NeckBreakRandomPlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void BreakNeck()
		{
			breakTime = Random.Range(MysteryDice.minNeckBreakTimer.Value, MysteryDice.maxNeckBreakTimer.Value);
			IsNeckBroken++;
		}

		public static void FixNeck()
		{
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			IsNeckBroken = 0;
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (!((Object)(object)localPlayerController == (Object)null))
			{
				Transform transform = ((Component)GameNetworkManager.Instance.localPlayerController.gameplayCamera).transform;
				if ((Object)(object)transform != (Object)null)
				{
					transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, 0f);
				}
			}
		}

		public static IEnumerator WaitTime()
		{
			isTimerRunning = true;
			MysteryDice.CustomLogger.LogInfo((object)$"Breaking neck for {breakTime} seconds");
			yield return (object)new WaitForSeconds(breakTime);
			FixNeck();
			isTimerRunning = false;
		}
	}
	internal class NeckSpin : IEffect
	{
		public static int IsNeckSpinning;

		public static float neckChoiceSpeed;

		public static int rotationNumber;

		public static bool wasClimbing;

		public static float savedValue;

		public static int counter;

		public string Name => "Neck Spin";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "ROTATION!";

		public void Use()
		{
			Networker.Instance.NeckSpinRandomPlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void SpinNeck()
		{
			rotationNumber = 0;
			counter = 0;
			float num = MysteryDice.rotationSpeedModifier.Value;
			if (MysteryDice.neckRotations.Value == -1)
			{
				num = 0f;
			}
			float value = MysteryDice.minNeckSpin.Value;
			float num2 = MysteryDice.maxNeckSpin.Value;
			if (num2 < value)
			{
				num2 = value;
			}
			neckChoiceSpeed = Random.Range(value + num, num2 + num);
			IsNeckSpinning = 1;
		}

		public static void FixNeck()
		{
			//IL_002d: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (!((Object)(object)localPlayerController == (Object)null))
			{
				IsNeckSpinning = 0;
				Transform transform = ((Component)localPlayerController.gameplayCamera).transform;
				transform.eulerAngles = new Vector3(transform.eulerAngles.x, transform.eulerAngles.y, 0f);
			}
		}
	}
	internal class Nemo : IEffect
	{
		public string Name => "Nemo";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Doot Doot Fish";

		public void Use()
		{
			int amount = Random.Range(3, 5);
			if (GetEnemies.Nemo != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Nemo, amount, isInside: false);
			}
		}
	}
	internal class Nemosplosion : IEffect
	{
		public string Name => "Nemosplosion";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Awww sad";

		public void Use()
		{
			Networker.Instance.NemosplosionServerRPC();
		}
	}
	internal class NutcrackerOutside : IEffect
	{
		public string Name => "21 Gun Salute";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "21 Gun Salute!";

		public void Use()
		{
			Networker.Instance.SpawnNutcrackerOutsideServerRPC();
		}

		public static void SpawnOutsideNutcracker()
		{
			if (GetEnemies.Nutcracker != null)
			{
				int amount = Random.Range(1, 6);
				RoundManager.Instance.currentOutsideEnemyPower = 0f;
				Misc.SpawnEnemyForced(GetEnemies.Nutcracker, amount, isInside: false);
			}
		}
	}
	internal class OopsAllBlank : IEffect
	{
		public string Name => "Oops All Blank";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Oops All *";

		public void Use()
		{
			Networker.Instance.OopsPlayerServerRPC();
		}
	}
	public class oopsController : MonoBehaviour
	{
		public UnlockableSuit currentSuit { get; set; }

		public UnlockableSuit suitToSwitchTo { get; set; }

		public PlayerControllerB player { get; set; }

		public void FixedUpdate()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded)
			{
				fixStuff();
			}
		}

		public void fixStuff()
		{
			currentSuit.SwitchSuitToThis(player);
			Object.Destroy((Object)(object)this);
		}

		public void switchSuit()
		{
			suitToSwitchTo.SwitchSuitToThis(player);
		}
	}
	internal class OutsideBracken : IEffect
	{
		public string Name => "Outside bracken";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Spawned a bracken outside!";

		public void Use()
		{
			Networker.Instance.OutsideBrackenServerRPC();
		}

		public static void SpawnOutsideBracken()
		{
			if (GetEnemies.Bracken != null)
			{
				RoundManager.Instance.currentOutsideEnemyPower = 0f;
				Misc.SpawnEnemyForced(GetEnemies.Bracken, 1, isInside: true);
				((MonoBehaviour)Networker.Instance).StartCoroutine(DelayedBrackenTeleportOutside());
			}
		}

		public static IEnumerator DelayedBrackenTeleportOutside()
		{
			yield return (object)new WaitForSeconds(3f);
			foreach (EnemyAI enemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (!(enemy is FlowermanAI))
				{
					continue;
				}
				FlowermanAI bracken = (FlowermanAI)enemy;
				EntranceTeleport[] allEntrances = Object.FindObjectsOfType<EntranceTeleport>();
				EntranceTeleport mainEntrance = null;
				for (int i = 0; i < allEntrances.Length; i++)
				{
					if (allEntrances[i].isEntranceToBuilding)
					{
						mainEntrance = allEntrances[i];
						break;
					}
				}
				if (!((Object)(object)mainEntrance == (Object)null))
				{
					((EnemyAI)bracken).allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
					((EnemyAI)bracken).isOutside = true;
					((EnemyAI)bracken).ChangeOwnershipOfEnemy(StartOfRound.Instance.allPlayerScripts[0].playerClientId);
					((EnemyAI)bracken).serverPosition = mainEntrance.entrancePoint.position;
					((Component)bracken).transform.position = ((EnemyAI)bracken).serverPosition;
					((EnemyAI)bracken).agent.Warp(((EnemyAI)bracken).serverPosition);
					((EnemyAI)bracken).SyncPositionToClients();
					((EnemyAI)bracken).EnableEnemyMesh(true, false, false);
					continue;
				}
				yield break;
			}
		}

		public static void SetNavmeshBrackenClient()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (spawnedEnemy is FlowermanAI)
				{
					FlowermanAI val = (FlowermanAI)spawnedEnemy;
					((EnemyAI)val).allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
				}
			}
		}
	}
	internal class OutsideBugs : IEffect
	{
		public string Name => "Outside Bugs";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "A lot of bugs spawned outside!";

		public void Use()
		{
			int amount = Random.Range(10, 15);
			if (GetEnemies.HoardingBug != null && GetEnemies.Centipede != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.HoardingBug, amount, isInside: false);
			}
		}
	}
	internal class OutsideCoilhead : IEffect
	{
		public string Name => "Outside coilhead";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Spawned a coilhead outside!";

		public void Use()
		{
			Networker.Instance.OutsideCoilheadServerRPC();
		}

		public static void SpawnOutsideCoilhead()
		{
			//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_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_0082: Unknown result type (might be due to invalid IL or missing references)
			if (GetEnemies.Coilhead != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Coilhead, 1, isInside: true);
				GameObject val = Object.Instantiate<GameObject>(GetEnemies.Coilhead.enemyType.enemyPrefab, GetMainEntrancePosition(), Quaternion.identity);
				val.GetComponentInChildren<NetworkObject>().Spawn(true);
				RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
				SetNavmesh(val.GetComponent<EnemyAI>(), outside: true);
				NetworkObjectReference netObj = NetworkObjectReference.op_Implicit(val.GetComponentInChildren<NetworkObject>());
				((MonoBehaviour)Networker.Instance).StartCoroutine(Networker.Instance.ServerDelayedCoilheadSetProperties(netObj));
			}
		}

		public static Vector3 GetMainEntrancePosition()
		{
			//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_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_0057: Unknown result type (might be due to invalid IL or missing references)
			EntranceTeleport[] array = Object.FindObjectsOfType<EntranceTeleport>();
			EntranceTeleport val = null;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].isEntranceToBuilding)
				{
					val = array[i];
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return Vector3.zero;
			}
			return ((Component)val).transform.position;
		}

		public static void SetNavmesh(EnemyAI enemy, bool outside)
		{
			if (outside)
			{
				enemy.allAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
			}
			else
			{
				enemy.allAINodes = GameObject.FindGameObjectsWithTag("InsideAINode");
			}
			enemy.isOutside = outside;
		}
	}
	internal class Overweight : GalEffect, IEffect
	{
		public string Name => "Overweight";

		public EffectType RealOutcome => EffectType.Good;

		public EffectType NoGalOutcome => EffectType.Mixed;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Heavy but Valuable";

		public void Use()
		{
			//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)
			for (int i = 0; i < 4; i++)
			{
				string itemName = StartOfRound.Instance.allItemsList.itemsList[Random.Range(0, StartOfRound.Instance.allItemsList.itemsList.Count)].itemName;
				Networker.Instance.SameScrapAdvancedServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, itemName, usePos: false, default(Vector3), -1, 5f, 4f);
			}
		}
	}
	internal class OxydePenalty : IEffect
	{
		public string Name => "Oxyde Penalty";

		public EffectType Outcome => EffectType.SpecialPenalty;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You shouldn't have done that";

		public void Use()
		{
			Networker.Instance.doOxydePenaltyServerRpc();
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void doPenalty()
		{
			foreach (EnemyLevelSpawner enemyLevelSpawner in EnemyLevelSpawner.enemyLevelSpawners)
			{
				if (!(enemyLevelSpawner is CompactorEnemyLevelSpawner))
				{
					enemyLevelSpawner.spawnTimer = 0f;
				}
			}
		}
	}
	internal class Paparazzi : IEffect
	{
		public static int MinMinesToSpawn = 3;

		public static int MaxMinesToSpawn = 6;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Paparazzi";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Papa-paparazzi";

		public void Use()
		{
			Networker.Instance.doPaparazziServerRPC();
		}

		public unsafe static void SpawnPaparazzi(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: 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_0236: 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_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_017d: 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_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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.Fan.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								GameObject val5 = Object.Instantiate<GameObject>(GetEnemies.FlashTurret.prefabToSpawn, val4.transform.position, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								NetworkObject component = val4.GetComponent<NetworkObject>();
								NetworkObject component2 = val5.GetComponent<NetworkObject>();
								((Object)val5).name = "Paparazzi";
								component.Spawn(true);
								component2.Spawn(true);
								Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3(0.2545f, 1f, 1f));
								val4.transform.SetParent(val5.transform);
								num++;
							}
						}
					}
					if (!flag)
					{
						ManualLogSource customLogger = MysteryDice.CustomLogger;
						Vector3 val6 = position;
						customLogger.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val6))/*cast due to .constrained prefix*/).ToString()));
					}
				}
				Networker.Instance.PlaySoundServerRPC("Paparazzi");
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class Papercut : IEffect
	{
		public string Name => "Papercut";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "They might cut you";

		public void Use()
		{
			Networker.Instance.paperCutServerRPC();
		}
	}
	internal class Pathfinder : IEffect
	{
		public class BlobspawnerBehaviour : PhysicsProp
		{
			private GameObject BlobModel = null;

			public override void Start()
			{
				((GrabbableObject)this).Start();
				BlobModel = ((Component)((Component)this).gameObject.transform.Find("Model")).gameObject;
			}

			public override void PocketItem()
			{
				BlobModel.SetActive(false);
				((GrabbableObject)this).PocketItem();
			}

			public override void EquipItem()
			{
				BlobModel.SetActive(true);
				((PhysicsProp)this).EquipItem();
			}

			public override void OnHitGround()
			{
				((GrabbableObject)this).OnHitGround();
				BlobModel.SetActive(true);
			}

			public override void ItemActivate(bool used, bool buttonDown = true)
			{
				((GrabbableObject)this).ItemActivate(used, buttonDown);
				if (buttonDown && !((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded)
				{
					Networker.Instance.PathfinderSpawnBlobsServerRPC();
					((GrabbableObject)this).DestroyObjectInHand(((GrabbableObject)this).playerHeldBy);
				}
			}

			protected override void __initializeVariables()
			{
				((PhysicsProp)this).__initializeVariables();
			}

			protected override void __initializeRpcs()
			{
				((PhysicsProp)this).__initializeRpcs();
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			protected internal override string __getTypeName()
			{
				return "BlobspawnerBehaviour";
			}
		}

		public class PathfindBehaviour : MonoBehaviour
		{
			private Vector3 EndPosition = Vector3.zero;

			private Vector3 GoingToPoint = Vector3.zero;

			private Vector3 PositionOffset = new Vector3(0f, 1f, 0f);

			private const float MaxVelocity = 2f;

			private const float DistanceTolerance = 1f;

			private float MoveVelocity = 2f;

			private float Timer = 1f;

			private int BlockedID = 0;

			private NavMeshPath path;

			private void Start()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				//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)
				EntranceTeleport[] array = Object.FindObjectsOfType<EntranceTeleport>(false);
				EntranceTeleport[] array2 = array;
				foreach (EntranceTeleport val in array2)
				{
					if (!val.isEntranceToBuilding && val.entranceId == 0)
					{
						EndPosition = val.entrancePoint.position;
						break;
					}
				}
				path = new NavMeshPath();
			}

			private void FixedUpdate()
			{
				//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_0079: 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_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_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_00ad: 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_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_002b: 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_003c: 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_00fb: 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_012a: Unknown result type (might be due to invalid IL or missing references)
				Timer -= Time.fixedDeltaTime;
				if (Timer < 0f)
				{
					NavMesh.CalculatePath(((Component)this).transform.position - PositionOffset, EndPosition, -1, path);
					BlockedID = 0;
					Timer = 1f;
					GetNewPath();
				}
				float num = Vector3.Distance(((Component)this).transform.position - PositionOffset, GoingToPoint);
				float num2 = Vector3.Distance(((Component)this).transform.position - PositionOffset, EndPosition);
				Vector3 val = GoingToPoint - ((Component)this).transform.position;
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				if (num < 1f)
				{
					GetNewPath();
				}
				else
				{
					((Component)this).transform.position = ((Component)this).transform.position + normalized * MoveVelocity * Time.fixedDeltaTime;
				}
				if (num2 < 1f)
				{
					Landmine.SpawnExplosion(((Component)this).transform.position, true, 0f, 0f, 0, 0f, (GameObject)null, false);
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
			}

			private void GetNewPath()
			{
				//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_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_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_006e: Unknown result type (might be due to invalid IL or missing references)
				for (int i = 0; i < path.corners.Length; i++)
				{
					if (Vector3.Distance(path.corners[i], ((Component)this).transform.position - PositionOffset) > 1f && i > BlockedID)
					{
						BlockedID = i;
						GoingToPoint = path.corners[i] + PositionOffset;
						break;
					}
				}
			}
		}

		public string Name => "Pathfinder";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You've got a pathfinder!";

		public void Use()
		{
			Networker.Instance.PathfinderGiveSpawnerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void GiveBlobItem(int userID)
		{
			//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)
			GameObject val = Object.Instantiate<GameObject>(MysteryDice.PathfinderSpawner.spawnPrefab, ((Component)Misc.GetPlayerByUserID(userID)).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
			val.GetComponent<GrabbableObject>().fallTime = 0f;
			val.GetComponent<NetworkObject>().Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(val.GetComponent<GrabbableObject>());
			val.GetComponent<GrabbableObject>().EnablePhysics(true);
		}

		public static void SpawnBlobs()
		{
			//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)
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (Misc.IsPlayerAliveAndControlled(val) && val.isInsideFactory)
				{
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.PathfinderPrefab, ((Component)val).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
					val2.GetComponent<NetworkObject>().Spawn(false);
				}
			}
		}
	}
	internal class PeaceTreaty : IEffect
	{
		public string Name => "PeaceTreaty";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Peace treaty";

		public void Use()
		{
			Networker.Instance.CustomMonsterServerRPC("Peace Keeper", 3, 5, IsInside: false);
		}
	}
	internal class PerformRandomEmote : IEffect
	{
		public string Name => "Random Emote Time";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Random Emote Time!!!";

		public void Use()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Networker.Instance.RequestEmotesInRadiusServerRpc(((Component)StartOfRound.Instance.localPlayerController).transform.position, 20f);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void PerformEmote()
		{
			List<UnlockableEmote> currentLoadoutEmotesList = EmoteMenu.currentLoadoutEmotesList;
			if (currentLoadoutEmotesList != null && currentLoadoutEmotesList.Count != 0)
			{
				UnlockableEmote val = currentLoadoutEmotesList[Random.Range(0, currentLoadoutEmotesList.Count)];
				if (val.inEmoteSyncGroup && val.emoteSyncGroup.Count > 0)
				{
					val = val.emoteSyncGroup[0];
				}
				EmoteControllerPlayer.emoteControllerLocal.TryPerformingEmoteLocal(val, -1, (GrabbablePropObject)null);
			}
		}
	}
	internal class Purge : IEffect
	{
		public string Name => "Purge";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "All living enemies explode";

		public void Use()
		{
			Networker.Instance.PurgeServerRPC();
		}

		public static void PurgeAllEnemies()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				try
				{
					Landmine.SpawnExplosion(((Component)spawnedEnemy).transform.position, true, 2f, 5f, 50, 0f, (GameObject)null, false);
					spawnedEnemy.KillEnemy(true);
					try
					{
						if (!spawnedEnemy.isEnemyDead)
						{
							NetworkObject component = ((Component)spawnedEnemy).GetComponent<NetworkObject>();
							if (((Object)((Component)component).gameObject).name != "Networker")
							{
								component.Despawn(true);
							}
							else
							{
								MysteryDice.CustomLogger.LogDebug((object)"Wat, why enemy named Networker??");
							}
						}
					}
					catch (Exception ex)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Probably not an error, but: " + ex.Message + "\n" + ex.StackTrace));
					}
				}
				catch (Exception ex2)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Probably not an error, but: " + ex2.Message + "\n" + ex2.StackTrace));
				}
			}
		}
	}
	internal class RandomGreatStoreItem : IEffect
	{
		public string Name => "Random Store Items";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Many random store items for you!";

		public void Use()
		{
			Networker.Instance.RandomStoreItemsServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(2, 5));
		}

		public static void SpawnItem(int playerID, int icount)
		{
			//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)
			Terminal val = Object.FindObjectOfType<Terminal>();
			List<Item> list = new List<Item>();
			for (int i = 0; i < icount; i++)
			{
				int num = Random.Range(0, val.buyableItemsList.Count());
				list.Add(val.buyableItemsList[num]);
			}
			foreach (Item item in list)
			{
				GameObject val2 = Object.Instantiate<GameObject>(item.spawnPrefab, ((Component)Misc.GetPlayerByUserID(playerID)).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
				val2.GetComponent<GrabbableObject>().fallTime = 0f;
				val2.GetComponent<NetworkObject>().Spawn(false);
				CullFactorySoftCompat.RefreshGrabbableObjectPosition(val2.GetComponent<GrabbableObject>());
				val2.GetComponent<GrabbableObject>().EnablePhysics(true);
			}
		}
	}
	internal class RandomStoreItem : IEffect
	{
		public string Name => "Random Store Item";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "A random store item for you!";

		public void Use()
		{
			Networker.Instance.RandomStoreItemServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void SpawnItem(int playerID, Vector3 position = default(Vector3))
		{
			//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_0036: 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_0052: 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)
			Terminal val = Object.FindObjectOfType<Terminal>();
			int num = Random.Range(0, val.buyableItemsList.Count());
			Item val2 = val.buyableItemsList[num];
			Vector3 val3 = ((Component)Misc.GetPlayerByUserID(playerID)).transform.position;
			if (position != default(Vector3))
			{
				val3 = position;
			}
			GameObject val4 = Object.Instantiate<GameObject>(val2.spawnPrefab, val3, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
			val4.GetComponent<GrabbableObject>().fallTime = 0f;
			val4.GetComponent<NetworkObject>().Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(val4.GetComponent<GrabbableObject>());
		}

		public static void SpawnItemNamed(int playerID, string name, Vector3 position = default(Vector3))
		{
			//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_005a: 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_0079: 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_0070: 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)
			Terminal val = Object.FindObjectOfType<Terminal>();
			int num = Random.Range(0, val.buyableItemsList.Count());
			Item val2 = (from x in val.buyableItemsList.ToList()
				where x.itemName == name
				select x).First();
			Vector3 val3 = ((Component)Misc.GetPlayerByUserID(playerID)).transform.position;
			if (position != default(Vector3))
			{
				val3 = position;
			}
			GameObject val4 = Object.Instantiate<GameObject>(val2.spawnPrefab, val3, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
			val4.GetComponent<GrabbableObject>().fallTime = 0f;
			val4.GetComponent<NetworkObject>().Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(val4.GetComponent<GrabbableObject>());
			val4.GetComponent<GrabbableObject>().EnablePhysics(true);
		}
	}
	internal class RebeliousCoilHeads : IEffect
	{
		public static bool IsEnabled;

		public string Name => "Rebelious Coilheads";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Coilheads randomly ignore if a player is looking at them.";

		public void Use()
		{
			Networker.Instance.EnableRebelServerRPC();
		}
	}
	internal class RemoveCredits : IEffect
	{
		public string Name => "Stolen Credits";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Who stole our credits?";

		public void Use()
		{
			Networker.Instance.AddMoneyServerRPC(Random.Range(-100, -300));
		}
	}
	internal class Reroll : IEffect
	{
		public string Name => "Reroll";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Try Again";

		public void Use()
		{
			Networker.Instance.RerollServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void DiceScrap(int userID)
		{
			//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_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_011a: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			RoundManager instance = RoundManager.Instance;
			List<Item> list = new List<Item>();
			List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
			List<int> list3 = new List<int>();
			List<float> list4 = new List<float>();
			list.Add(MysteryDice.RegisteredDice[Random.Range(0, MysteryDice.RegisteredDice.Count)]);
			foreach (Item item in list)
			{
				GameObject val = Object.Instantiate<GameObject>(item.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
				component.fallTime = 0f;
				component.scrapValue = (int)((float)Random.Range(item.minValue, item.maxValue) * instance.scrapValueMultiplier);
				list3.Add(component.scrapValue);
				list4.Add(component.itemProperties.weight);
				NetworkObject component2 = val.GetComponent<NetworkObject>();
				component2.Spawn(false);
				component.FallToGround(false, true, ((Component)playerByUserID).transform.position);
				list2.Add(NetworkObjectReference.op_Implicit(component2));
			}
			((MonoBehaviour)instance).StartCoroutine(DelayedSync(instance, list2.ToArray(), list3.ToArray(), list4.ToArray()));
		}

		public static IEnumerator DelayedSync(RoundManager RM, NetworkObjectReference[] netObjs, int[] scrapValues, float[] scrapWeights)
		{
			yield return (object)new WaitForSeconds(3f);
			RM.SyncScrapValuesClientRpc(netObjs, scrapValues);
			Networker.Instance.SyncItemWeightsClientRPC(netObjs, scrapWeights);
		}

		public static void DiceScrapWithEffect(int userID, string effect)
		{
			//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_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_0097: 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_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_0140: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			RoundManager instance = RoundManager.Instance;
			List<Item> list = new List<Item>();
			List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
			List<int> list3 = new List<int>();
			List<float> list4 = new List<float>();
			list.Add(MysteryDice.RegisteredDice[Random.Range(0, MysteryDice.RegisteredDice.Count)]);
			Vector3 position = ((Component)playerByUserID).transform.position;
			if (playerByUserID.isPlayerDead)
			{
				position = ((Component)StartOfRound.Instance.spectateCamera).transform.position;
			}
			foreach (Item item in list)
			{
				GameObject val = Object.Instantiate<GameObject>(item.spawnPrefab, position, Quaternion.identity, instance.spawnedScrapContainer);
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
				component.fallTime = 0f;
				component.scrapValue = (int)((float)Random.Range(item.minValue, item.maxValue) * instance.scrapValueMultiplier);
				list3.Add(component.scrapValue);
				list4.Add(component.itemProperties.weight);
				NetworkObject component2 = val.GetComponent<NetworkObject>();
				component2.Spawn(false);
				component.FallToGround(false, true, ((Component)playerByUserID).transform.position);
				list2.Add(NetworkObjectReference.op_Implicit(component2));
			}
			((MonoBehaviour)instance).StartCoroutine(DelayedSync(instance, list2.ToArray(), list3.ToArray(), list4.ToArray()));
			Networker.Instance.setDiceEffectServerRPC(list2[0], effect);
		}
	}
	internal class RerollALL : GalEffect, IEffect
	{
		public string Name => "RerollALL";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Try Again";

		public void Use()
		{
			Networker.Instance.RerollAllServerRPC();
		}
	}
	internal class ReturnToShip : IEffect
	{
		public string Name => "Return to ship";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Returning to ship with items!";

		public void Use()
		{
			Networker.Instance.TeleportToShipServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}

		public static void TeleportPlayerToShip(int clientID)
		{
			//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_00ca: Unknown result type (might be due to invalid IL or missing references)
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Teleporting Player To Ship");
			}
			PlayerControllerB val = null;
			val = StartOfRound.Instance.allPlayerScripts[clientID];
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				if (Object.op_Implicit((Object)(object)Object.FindObjectOfType<AudioReverbPresets>()))
				{
					Object.FindObjectOfType<AudioReverbPresets>().audioPresets[3].ChangeAudioReverbForPlayer(val);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogDebug((object)("Probably not an error, but: " + ex.Message + "\n" + ex.StackTrace));
			}
			val.isInElevator = true;
			val.isInHangarShipRoom = true;
			val.isInsideFactory = false;
			val.averageVelocity = 0f;
			val.velocityLastFrame = Vector3.zero;
			val.TeleportPlayer(StartOfRound.Instance.middleOfShipNode.position, true, 160f, false, true);
			val.beamOutParticle.Play();
			if ((Object)(object)val == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
			}
		}
	}
	internal class ReturnToShipTogether : IEffect
	{
		public static float DistanceToCaller = 8f;

		public string Name => "Return to ship together";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Returning to ship with your nearest crewmates!";

		public void Use()
		{
			TeleportToShipTogether(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}

		public static void TeleportToShipTogether(int callerID)
		{
			//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)
			PlayerControllerB val = null;
			val = StartOfRound.Instance.allPlayerScripts[callerID];
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			List<int> list = new List<int>();
			GameObject[] allPlayerObjects = StartOfRound.Instance.allPlayerObjects;
			foreach (GameObject val2 in allPlayerObjects)
			{
				PlayerControllerB component = val2.GetComponent<PlayerControllerB>();
				if (!((Object)(object)component == (Object)null) && Misc.IsPlayerAliveAndControlled(component) && Vector3.Distance(((Component)component).transform.position, ((Component)val).transform.position) < DistanceToCaller)
				{
					list.Add(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, component));
				}
			}
			foreach (int item in list)
			{
				Networker.Instance.ReturnPlayerToShipServerRPC(item);
			}
		}
	}
	internal class Revive : GalEffect, IEffect
	{
		public static int lives;

		public string Name => "Revive All";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Reviving everyone";

		public void Use()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerDead)
				{
					Networker.Instance.RevivePlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val), StartOfRound.Instance.middleOfShipNode.position);
				}
			}
		}

		public static void revivePlayer(int playerID, Vector3 SpawnPosition)
		{
			//IL_00d6: 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_021b: Unknown result type (might be due to invalid IL or missing references)
			int num = 100;
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerID];
			if (!val.isPlayerDead)
			{
				return;
			}
			val.isInsideFactory = false;
			val.isInHangarShipRoom = true;
			val.ResetPlayerBloodObjects(val.isPlayerDead);
			val.health = num;
			val.isClimbingLadder = false;
			val.clampLooking = false;
			val.inVehicleAnimation = false;
			val.disableMoveInput = false;
			val.disableLookInput = false;
			val.disableInteract = false;
			val.ResetZAndXRotation();
			((Collider)val.thisController).enabled = true;
			if (val.isPlayerDead)
			{
				((Collider)val.thisController).enabled = true;
				val.isPlayerDead = false;
				val.isPlayerControlled = true;
				val.health = num;
				val.hasBeenCriticallyInjured = false;
				val.criticallyInjured = false;
				val.playerBodyAnimator.SetBool("Limp", false);
				val.TeleportPlayer(SpawnPosition, false, 0f, false, true);
				val.parentedToElevatorLastFrame = false;
				val.overrideGameOverSpectatePivot = null;
				StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
				val.setPositionOfDeadPlayer = false;
				val.DisablePlayerModel(((Component)val).gameObject, true, true);
				((Behaviour)val.helmetLight).enabled = false;
				val.Crouch(false);
				if ((Object)(object)val.playerBodyAnimator != (Object)null)
				{
					val.playerBodyAnimator.SetBool("Limp", false);
				}
				val.bleedingHeavily = false;
				if ((Object)(object)val.deadBody != (Object)null)
				{
					((Behaviour)val.deadBody).enabled = false;
					((Component)val.deadBody).gameObject.SetActive(false);
				}
				val.deadBody = null;
				val.activatingItem = false;
				val.twoHanded = false;
				val.inShockingMinigame = false;
				val.inSpecialInteractAnimation = false;
				val.freeRotationInInteractAnimation = false;
				val.disableSyncInAnimation = false;
				val.inAnimationWithEnemy = null;
				val.holdingWalkieTalkie = false;
				val.speakingToWalkieTalkie = false;
				val.isSinking = false;
				val.isUnderwater = false;
				val.sinkingValue = 0f;
				val.statusEffectAudio.Stop();
				val.DisableJetpackControlsLocally();
				val.mapRadarDotAnimator.SetBool("dead", false);
				val.hasBegunSpectating = false;
				val.externalForceAutoFade = Vector3.zero;
				val.hinderedMultiplier = 1f;
				val.isMovementHindered = 0;
				val.sourcesCausingSinking = 0;
				val.reverbPreset = StartOfRound.Instance.shipReverb;
				SoundManager.Instance.earsRingingTimer = 0f;
				val.voiceMuffledByEnemy = false;
				SoundManager.Instance.playerVoicePitchTargets[playerID] = 1f;
				SoundManager.Instance.SetPlayerPitch(1f, playerID);
				if ((Object)(object)val.currentVoiceChatIngameSettings == (Object)null)
				{
					StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
				}
				if ((Object)(object)val.currentVoiceChatIngameSettings != (Object)null)
				{
					if ((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						val.currentVoiceChatIngameSettings.InitializeComponents();
					}
					if ((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						return;
					}
					((Component)val.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
				}
				if (val.isPlayerDead)
				{
					HUDManager.Instance.UpdateBoxesSpectateUI();
					HUDManager.Instance.UpdateSpectateBoxSpeakerIcons();
				}
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)(object)val)
			{
				localPlayerController.bleedingHeavily = false;
				localPlayerController.criticallyInjured = false;
				localPlayerController.health = num;
				HUDManager.Instance.UpdateHealthUI(num, true);
				localPlayerController.playerBodyAnimator.SetBool("Limp", false);
				localPlayerController.spectatedPlayerScript = null;
				StartOfRound.Instance.SetSpectateCameraToGameOverMode(false, localPlayerController);
				StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
				((Behaviour)HUDManager.Instance.audioListenerLowPass).enabled = false;
				HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
				HUDManager.Instance.RemoveSpectateUI();
				HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
				HUDManager.Instance.HideHUD(false);
			}
			StartOfRound.Instance.allPlayersDead = false;
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			StartOfRound.Instance.UpdatePlayerVoiceEffects();
		}

		public static int CountDeadPlayers()
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			int num = 0;
			for (int i = 0; i < allPlayerScripts.Length; i++)
			{
				if (allPlayerScripts[i].isPlayerDead)
				{
					num++;
				}
			}
			return num;
		}

		public static PlayerControllerB getRandomDeadPlayer()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerDead)
				{
					list.Add(val);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			return list[Random.Range(0, list.Count)];
		}

		public static IEnumerator reviveNext()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => CountDeadPlayers() != 0));
			PlayerControllerB player = getRandomDeadPlayer();
			Networker.Instance.RevivePlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), StartOfRound.Instance.middleOfShipNode.position);
		}
	}
	internal class ReviveNext : IEffect
	{
		public string Name => "Revive Next";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "One Revive";

		public void Use()
		{
			Networker.Instance.reviveNextServerRPC();
		}
	}
	internal class RevivePercent : IEffect
	{
		public string Name => "Revive Percent";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Maybe Revives";

		public void Use()
		{
			float percentChance = Random.Range(0.01f, 0.65f);
			Networker.Instance.reviveChanceServerRPC(percentChance);
		}
	}
	internal class Rigo : IEffect
	{
		public string Name => "Duolingo Cousin";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Boom Language Learned";

		public void Use()
		{
			//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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(1, 5), "Rodriguez");
		}
	}
	internal class ScaryMon : IEffect
	{
		public string Name => "Scary?";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Fear Incarnate";

		public void Use()
		{
			int amount = Random.Range(3, 12);
			if (GetEnemies.Scary != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Scary, amount, isInside: true);
			}
		}
	}
	internal class ScrapJackpot : IEffect
	{
		public string Name => "Scrap jackpot";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Spawning more scrap!";

		public void Use()
		{
			Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(3, 9));
		}

		public static void JackpotScrap(int userID, int amount)
		{
			//IL_00f4: 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_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_01ad: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			RoundManager instance = RoundManager.Instance;
			List<Item> list = new List<Item>();
			List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
			List<int> list3 = new List<int>();
			List<float> list4 = new List<float>();
			List<int> list5 = new List<int>(instance.currentLevel.spawnableScrap.Count);
			for (int i = 0; i < instance.currentLevel.spawnableScrap.Count; i++)
			{
				list5.Add(instance.currentLevel.spawnableScrap[i].rarity);
			}
			int[] array = list5.ToArray();
			for (int j = 0; j < amount; j++)
			{
				list.Add(instance.currentLevel.spawnableScrap[instance.GetRandomWeightedIndex(array, (Random)null)].spawnableItem);
			}
			foreach (Item item in list)
			{
				GameObject val = Object.Instantiate<GameObject>(item.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
				component.fallTime = 0f;
				component.scrapValue = (int)((float)Random.Range(item.minValue, item.maxValue) * instance.scrapValueMultiplier);
				list3.Add(component.scrapValue);
				list4.Add(component.itemProperties.weight);
				NetworkObject component2 = val.GetComponent<NetworkObject>();
				component2.Spawn(false);
				CullFactorySoftCompat.RefreshGrabbableObjectPosition(val.GetComponent<GrabbableObject>());
				component.FallToGround(false, true, ((Component)playerByUserID).transform.position);
				list2.Add(NetworkObjectReference.op_Implicit(component2));
			}
			((MonoBehaviour)instance).StartCoroutine(DelayedSync(instance, list2.ToArray(), list3.ToArray(), list4.ToArray()));
		}

		public static IEnumerator DelayedSync(RoundManager RM, NetworkObjectReference[] netObjs, int[] scrapValues, float[] scrapWeights)
		{
			yield return (object)new WaitForSeconds(3f);
			RM.SyncScrapValuesClientRpc(netObjs, scrapValues);
			Networker.Instance.SyncItemWeightsClientRPC(netObjs, scrapWeights);
		}
	}
	internal class SeaminesOutside : IEffect
	{
		public static int MinMinesToSpawn = 4;

		public static int MaxMinesToSpawn = 8;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Seamines";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Where they are supposed to be";

		public void Use()
		{
			Networker.Instance.SeaminesOutsideServerRPC();
		}

		public unsafe static void SpawnSeaminesOutside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_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_014c: 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_017f: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.Seamine.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								val4.GetComponent<NetworkObject>().Spawn(true);
								num++;
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class SelectEffect : IEffect
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__12_0;

			public static Func<IEffect, string> <>9__13_1;

			public static Func<SelectableLevel, IEnumerable<SpawnableEnemyWithRarity>> <>9__14_1;

			public static Func<SpawnableEnemyWithRarity, string> <>9__14_2;

			public static Func<IGrouping<string, SpawnableEnemyWithRarity>, SpawnableEnemyWithRarity> <>9__14_3;

			public static Func<SpawnableEnemyWithRarity, string> <>9__14_5;

			public static Func<SelectableLevel, IEnumerable<SpawnableEnemyWithRarity>> <>9__15_1;

			public static Func<SpawnableEnemyWithRarity, string> <>9__15_2;

			public static Func<IGrouping<string, SpawnableEnemyWithRarity>, SpawnableEnemyWithRarity> <>9__15_3;

			public static Func<SpawnableEnemyWithRarity, string> <>9__15_5;

			public static Func<SelectableLevel, IEnumerable<SpawnableMapObject>> <>9__16_1;

			public static Func<SpawnableMapObject, string> <>9__16_2;

			public static Func<IGrouping<string, SpawnableMapObject>, SpawnableMapObject> <>9__16_3;

			public static Func<SpawnableMapObject, string> <>9__16_5;

			public static Func<SelectableLevel, IEnumerable<SpawnableItemWithRarity>> <>9__17_1;

			public static Func<SpawnableItemWithRarity, string> <>9__17_2;

			public static Func<IGrouping<string, SpawnableItemWithRarity>, SpawnableItemWithRarity> <>9__17_3;

			public static Func<SpawnableItemWithRarity, string> <>9__17_5;

			public static Func<SpawnableOutsideObjectWithRarity, string> <>9__18_1;

			public static Func<IGrouping<string, SpawnableOutsideObjectWithRarity>, SpawnableOutsideObjectWithRarity> <>9__18_2;

			public static Func<SpawnableOutsideObjectWithRarity, string> <>9__18_3;

			public static Func<Item, string> <>9__19_1;

			public static Func<IGrouping<string, Item>, Item> <>9__19_2;

			public static Func<Item, string> <>9__19_4;

			public static Func<PlayerControllerB, string> <>9__20_1;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__20_2;

			public static Func<PlayerControllerB, string> <>9__20_3;

			public static Func<PlayerControllerB, string> <>9__24_1;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__24_2;

			public static Func<PlayerControllerB, string> <>9__24_3;

			public static Func<PlayerControllerB, string> <>9__25_1;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__25_2;

			public static Func<PlayerControllerB, string> <>9__25_3;

			public static Func<PlayerControllerB, string> <>9__26_1;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__26_2;

			public static Func<PlayerControllerB, string> <>9__26_3;

			public static Func<UnlockableSuit, string> <>9__26_6;

			public static Func<PlayerControllerB, string> <>9__29_1;

			public static Func<IGrouping<string, PlayerControllerB>, PlayerControllerB> <>9__29_2;

			public static Func<PlayerControllerB, string> <>9__29_3;

			public static UnityAction <>9__30_0;

			public static Func<KeyValuePair<string, AudioClip>, string> <>9__31_1;

			internal void <showDebugMenu>b__12_0()
			{
				CloseSelectMenu();
			}

			internal string <getOrdered>b__13_1(IEffect effect)
			{
				return effect.Name;
			}

			internal IEnumerable<SpawnableEnemyWithRarity> <spawnEnemy>b__14_1(SelectableLevel level)
			{
				return level.Enemies.Union(level.OutsideEnemies).Union(level.DaytimeEnemies);
			}

			internal string <spawnEnemy>b__14_2(SpawnableEnemyWithRarity x)
			{
				return x.enemyType.enemyName;
			}

			internal SpawnableEnemyWithRarity <spawnEnemy>b__14_3(IGrouping<string, SpawnableEnemyWithRarity> g)
			{
				return g.First();
			}

			internal string <spawnEnemy>b__14_5(SpawnableEnemyWithRarity e)
			{
				return e.enemyType.enemyName;
			}

			internal IEnumerable<SpawnableEnemyWithRarity> <spawnMiniEnemy>b__15_1(SelectableLevel level)
			{
				return level.Enemies.Union(level.OutsideEnemies).Union(level.DaytimeEnemies);
			}

			internal string <spawnMiniEnemy>b__15_2(SpawnableEnemyWithRarity x)
			{
				return x.enemyType.enemyName;
			}

			internal SpawnableEnemyWithRarity <spawnMiniEnemy>b__15_3(IGrouping<string, SpawnableEnemyWithRarity> g)
			{
				return g.First();
			}

			internal string <spawnMiniEnemy>b__15_5(SpawnableEnemyWithRarity e)
			{
				return e.enemyType.enemyName;
			}

			internal IEnumerable<SpawnableMapObject> <spawnTrap>b__16_1(SelectableLevel level)
			{
				return level.spawnableMapObjects;
			}

			internal string <spawnTrap>b__16_2(SpawnableMapObject x)
			{
				return ((Object)x.prefabToSpawn).name;
			}

			internal SpawnableMapObject <spawnTrap>b__16_3(IGrouping<string, SpawnableMapObject> g)
			{
				return g.First();
			}

			internal string <spawnTrap>b__16_5(SpawnableMapObject t)
			{
				return ((Object)t.prefabToSpawn).name;
			}

			internal IEnumerable<SpawnableItemWithRarity> <spawnScrap>b__17_1(SelectableLevel level)
			{
				return level.spawnableScrap;
			}

			internal string <spawnScrap>b__17_2(SpawnableItemWithRarity x)
			{
				return x.spawnableItem.itemName;
			}

			internal SpawnableItemWithRarity <spawnScrap>b__17_3(IGrouping<string, SpawnableItemWithRarity> g)
			{
				return g.First();
			}

			internal string <spawnScrap>b__17_5(SpawnableItemWithRarity s)
			{
				return s.spawnableItem.itemName;
			}

			internal string <spawnWorldObject>b__18_1(SpawnableOutsideObjectWithRarity x)
			{
				return ((Object)x.spawnableObject).name;
			}

			internal SpawnableOutsideObjectWithRarity <spawnWorldObject>b__18_2(IGrouping<string, SpawnableOutsideObjectWithRarity> g)
			{
				return g.First();
			}

			internal string <spawnWorldObject>b__18_3(SpawnableOutsideObjectWithRarity x)
			{
				return ((Object)x.spawnableObject).name;
			}

			internal string <spawnShopItems>b__19_1(Item x)
			{
				return x.itemName;
			}

			internal Item <spawnShopItems>b__19_2(IGrouping<string, Item> g)
			{
				return g.First();
			}

			internal string <spawnShopItems>b__19_4(Item s)
			{
				return s.itemName;
			}

			internal string <grantAdmin>b__20_1(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <grantAdmin>b__20_2(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <grantAdmin>b__20_3(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <TeleportPlayer>b__24_1(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <TeleportPlayer>b__24_2(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <TeleportPlayer>b__24_3(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ForceSuitPlayerSelector>b__25_1(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <ForceSuitPlayerSelector>b__25_2(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <ForceSuitPlayerSelector>b__25_3(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ForceSuitSuitSelector>b__26_1(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <ForceSuitSuitSelector>b__26_2(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <ForceSuitSuitSelector>b__26_3(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal string <ForceSuitSuitSelector>b__26_6(UnlockableSuit suit)
			{
				return (suit.syncedSuitID.Value >= 0 && suit.syncedSuitID.Value < StartOfRound.Instance.unlockablesList.unlockables.Count) ? StartOfRound.Instance.unlockablesList.unlockables[suit.syncedSuitID.Value].unlockableName : string.Empty;
			}

			internal string <RevivePlayer>b__29_1(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal PlayerControllerB <RevivePlayer>b__29_2(IGrouping<string, PlayerControllerB> g)
			{
				return g.First();
			}

			internal string <RevivePlayer>b__29_3(PlayerControllerB x)
			{
				return x.playerUsername;
			}

			internal void <ShowSelectMenu>b__30_0()
			{
				CloseSelectMenu();
			}

			internal string <ShowSoundMenu>b__31_1(KeyValuePair<string, AudioClip> x)
			{
				return x.Key;
			}
		}

		public static bool ReviveOpen = false;

		public static GameObject EffectMenu = null;

		public static Dictionary<string, bool> currentStuff = new Dictionary<string, bool>();

		public string Name => "Select Effect";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You can select an effect";

		public static bool isSpecial()
		{
			return StartOfRound.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID || StartOfRound.Instance.localPlayerController.playerSteamId == 76561199094139351L || StartOfRound.Instance.localPlayerController.playerSteamId == 76561198086086035L || GameNetworkManager.Instance.disableSteam;
		}

		public void Use()
		{
			DebugMenuStuff.ShowSelectEffectMenu();
		}

		public static void showDebugMenu(bool full, bool complete, bool su = false)
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//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_00a3: Expected O, but got Unknown
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			ButtonClickedEvent onClick = component.onClick;
			object obj = <>c.<>9__12_0;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					CloseSelectMenu();
				};
				<>c.<>9__12_0 = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component2 = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component2.text = "Choose a Category";
			TMP_Text component3 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
			component3.text = "Select Effect";
			Button component4 = val3.GetComponent<Button>();
			((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				ShowSelectMenu(full, complete, su);
			});
			GameObject val4 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component5 = ((Component)val4.transform.GetChild(0)).GetComponent<TMP_Text>();
			component5.text = "Spawn Stuff";
			Button component6 = val4.GetComponent<Button>();
			((UnityEvent)component6.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				spawnFunctions(full, complete, su);
			});
			GameObject val5 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component7 = ((Component)val5.transform.GetChild(0)).GetComponent<TMP_Text>();
			component7.text = "Player Functions";
			Button component8 = val5.GetComponent<Button>();
			((UnityEvent)component8.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				playerFunctions(full, complete, su);
			});
			if (isSpecial())
			{
				GameObject val6 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component9 = ((Component)val6.transform.GetChild(0)).GetComponent<TMP_Text>();
				component9.text = "Special Functions";
				Button component10 = val6.GetComponent<Button>();
				((UnityEvent)component10.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					specialFunctions(full, complete, su);
				});
			}
			if (su)
			{
				GameObject val7 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component11 = ((Component)val7.transform.GetChild(0)).GetComponent<TMP_Text>();
				component11.text = "Grant/Revoke Admin";
				Button component12 = val7.GetComponent<Button>();
				((UnityEvent)component12.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					grantAdmin(full, complete, su);
				});
			}
		}

		public static List<IEffect> getOrdered(bool full, bool complete = false)
		{
			List<IEffect> list = new List<IEffect>(complete ? DieBehaviour.CompleteEffects : (full ? DieBehaviour.AllEffects : DieBehaviour.AllowedEffects));
			if (StartOfRound.Instance.localPlayerController.playerSteamId == MysteryDice.slayerSteamID || StartOfRound.Instance.localPlayerController.playerSteamId == 76561199094139351L || StartOfRound.Instance.localPlayerController.playerSteamId == 76561198984467725L)
			{
				list.Add(new ForceTakeoff());
			}
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteEffectNames = favoriteData.Favorites;
			return list.OrderByDescending((IEffect effect) => favoriteEffectNames.Contains(effect.Name)).ThenBy<IEffect, string>((IEffect effect) => effect.Name, StringComparer.OrdinalIgnoreCase).ToList();
		}

		public static void spawnEnemy(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0269: 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_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Spawn an Enemy";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				spawnFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteEnemyNames = favoriteData.FavoriteEnemies;
			List<SpawnableEnemyWithRarity> source = (from x in StartOfRound.Instance.levels.SelectMany((SelectableLevel level) => level.Enemies.Union(level.OutsideEnemies).Union(level.DaytimeEnemies))
				group x by x.enemyType.enemyName into g
				select g.First()).ToList();
			source = (from e in source
				orderby (!favoriteEnemyNames.Contains(e.enemyType.enemyName)) ? 1 : 0, e.enemyType.enemyName
				select e).ToList();
			foreach (SpawnableEnemyWithRarity enemy in source)
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteEnemyNames.Contains(enemy.enemyType.enemyName);
				string text = (flag ? "*" : "");
				component4.text = text + " " + enemy.enemyType.enemyName;
				((Graphic)component4).color = (flag ? Color.gray : Color.black);
				Button component5 = val2.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					//IL_004d: 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)
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					if (StartOfRound.Instance.localPlayerController.isPlayerDead)
					{
						Networker.Instance.SpawnEnemyAtPosServerRPC(enemy.enemyType.enemyName, ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					}
					else
					{
						Networker.Instance.CustomMonsterServerRPC(enemy.enemyType.enemyName, 1, 1, StartOfRound.Instance.localPlayerController.isInsideFactory);
					}
					string text2 = (StartOfRound.Instance.localPlayerController.isInsideFactory ? "Inside" : "Outside");
					string body = "Spawned " + enemy.enemyType.enemyName + " " + text2;
					Misc.SafeTipMessage("Spawned " + enemy.enemyType.enemyName, body);
				});
				RightClickHandler rightClickHandler = val2.AddComponent<RightClickHandler>();
				rightClickHandler.effectName = enemy.enemyType.enemyName;
				rightClickHandler.category = "FavoriteEnemies";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnMiniEnemy(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0269: 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_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Spawn an Mini Enemy";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				specialFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteEnemyNames = favoriteData.FavoriteEnemies;
			List<SpawnableEnemyWithRarity> source = (from x in StartOfRound.Instance.levels.SelectMany((SelectableLevel level) => level.Enemies.Union(level.OutsideEnemies).Union(level.DaytimeEnemies))
				group x by x.enemyType.enemyName into g
				select g.First()).ToList();
			source = (from e in source
				orderby (!favoriteEnemyNames.Contains(e.enemyType.enemyName)) ? 1 : 0, e.enemyType.enemyName
				select e).ToList();
			foreach (SpawnableEnemyWithRarity enemy in source)
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteEnemyNames.Contains(enemy.enemyType.enemyName);
				string text = (flag ? "*" : "");
				component4.text = text + " " + enemy.enemyType.enemyName;
				((Graphic)component4).color = (flag ? Color.gray : Color.black);
				Button component5 = val2.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					//IL_0095: 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_004d: 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 (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					if (StartOfRound.Instance.localPlayerController.isPlayerDead)
					{
						Networker.Instance.SpawnEnemyAtPosServerRPC(enemy.enemyType.enemyName, ((Component)StartOfRound.Instance.spectateCamera).transform.position, useSize: true, new Vector3(0.25f, 0.25f, 0.25f));
					}
					else
					{
						Networker.Instance.SpawnEnemyAtPosServerRPC(enemy.enemyType.enemyName, ((Component)StartOfRound.Instance.localPlayerController).transform.position, useSize: true, new Vector3(0.25f, 0.25f, 0.25f));
					}
					string text2 = (StartOfRound.Instance.localPlayerController.isInsideFactory ? "Inside" : "Outside");
					string body = "Spawned " + enemy.enemyType.enemyName + " " + text2;
					Misc.SafeTipMessage("Spawned " + enemy.enemyType.enemyName, body);
				});
				RightClickHandler rightClickHandler = val2.AddComponent<RightClickHandler>();
				rightClickHandler.effectName = enemy.enemyType.enemyName;
				rightClickHandler.category = "FavoriteEnemies";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnTrap(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0269: 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_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Spawn a Trap";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				spawnFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteTrapNames = favoriteData.FavoriteTraps;
			List<SpawnableMapObject> source = (from x in StartOfRound.Instance.levels.SelectMany((SelectableLevel level) => level.spawnableMapObjects)
				group x by ((Object)x.prefabToSpawn).name into g
				select g.First()).ToList();
			source = (from t in source
				orderby (!favoriteTrapNames.Contains(((Object)t.prefabToSpawn).name)) ? 1 : 0, ((Object)t.prefabToSpawn).name
				select t).ToList();
			foreach (SpawnableMapObject trap in source)
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteTrapNames.Contains(((Object)trap.prefabToSpawn).name);
				string text = (flag ? "*" : "");
				component4.text = text + " " + ((Object)trap.prefabToSpawn).name;
				((Graphic)component4).color = (flag ? Color.gray : Color.black);
				Button component5 = val2.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					//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_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_00a5: 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)
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					Vector3 val3 = ((!StartOfRound.Instance.localPlayerController.isPlayerDead) ? ((Component)StartOfRound.Instance.localPlayerController).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					Networker.Instance.spawnTrapOnServerRPC(((Object)trap.prefabToSpawn).name, 1, StartOfRound.Instance.localPlayerController.isInsideFactory, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), StartOfRound.Instance.localPlayerController.isPlayerDead, val3);
					Misc.SafeTipMessage("Spawned " + ((Object)trap.prefabToSpawn).name, $"Spawned at {val3}");
				});
				RightClickHandler rightClickHandler = val2.AddComponent<RightClickHandler>();
				rightClickHandler.effectName = ((Object)trap.prefabToSpawn).name;
				rightClickHandler.category = "FavoriteTraps";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnScrap(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0269: 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_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Spawn Scrap";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				spawnFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteScrapNames = favoriteData.FavoriteScraps;
			List<SpawnableItemWithRarity> source = (from x in StartOfRound.Instance.levels.SelectMany((SelectableLevel level) => level.spawnableScrap)
				group x by x.spawnableItem.itemName into g
				select g.First()).ToList();
			source = (from s in source
				orderby (!favoriteScrapNames.Contains(s.spawnableItem.itemName)) ? 1 : 0, s.spawnableItem.itemName
				select s).ToList();
			foreach (SpawnableItemWithRarity scrap in source)
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteScrapNames.Contains(scrap.spawnableItem.itemName);
				string text = (flag ? "*" : "");
				component4.text = text + " " + scrap.spawnableItem.itemName;
				((Graphic)component4).color = (flag ? Color.gray : Color.black);
				Button component5 = val2.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					//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_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_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)
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					Vector3 val3 = ((!StartOfRound.Instance.localPlayerController.isPlayerDead) ? ((Component)StartOfRound.Instance.localPlayerController).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, scrap.spawnableItem.itemName, StartOfRound.Instance.localPlayerController.isPlayerDead, val3);
					Misc.SafeTipMessage("Spawned " + ((Object)scrap.spawnableItem).name, $"Spawned at {val3}");
				});
				RightClickHandler rightClickHandler = val2.AddComponent<RightClickHandler>();
				rightClickHandler.effectName = scrap.spawnableItem.itemName;
				rightClickHandler.category = "FavoriteScraps";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void spawnWorldObject(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Spawn Objects";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				showDebugMenu(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<SpawnableOutsideObjectWithRarity> list = new List<SpawnableOutsideObjectWithRarity>();
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel val2 in levels)
			{
				list = list.Union(val2.spawnableOutsideObjects).ToList();
			}
			list = (from x in list
				group x by ((Object)x.spawnableObject).name into g
				select g.First() into x
				orderby ((Object)x.spawnableObject).name
				select x).ToList();
			foreach (SpawnableOutsideObjectWithRarity scrap in list)
			{
				GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
				component4.text = ((Object)scrap.spawnableObject).name ?? "";
				Button component5 = val3.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					Networker.Instance.SpawnObjectServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, ((Object)scrap.spawnableObject).name);
					string text = "";
					text = "Spawned " + ((Object)scrap.spawnableObject).name;
					Misc.SafeTipMessage("Object Spawned", text);
				});
			}
		}

		public static void spawnShopItems(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_023f: 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_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Spawn Shop Items";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				spawnFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			List<string> favoriteShopItemNames = favoriteData.FavoriteShopItems;
			Terminal val2 = Object.FindObjectOfType<Terminal>();
			List<Item> source = (from x in val2.buyableItemsList
				group x by x.itemName into g
				select g.First()).ToList();
			source = (from s in source
				orderby (!favoriteShopItemNames.Contains(s.itemName)) ? 1 : 0, s.itemName
				select s).ToList();
			foreach (Item item in source)
			{
				GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
				bool flag = favoriteShopItemNames.Contains(item.itemName);
				string text = (flag ? "*" : "");
				component4.text = text + " " + item.itemName;
				((Graphic)component4).color = (flag ? Color.gray : Color.black);
				Button component5 = val3.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					//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_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_0081: Unknown result type (might be due to invalid IL or missing references)
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					Vector3 position = ((!StartOfRound.Instance.localPlayerController.isPlayerDead) ? ((Component)StartOfRound.Instance.localPlayerController).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
					Networker.Instance.spawnStoreItemServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), item.itemName, position);
				});
				RightClickHandler rightClickHandler = val3.AddComponent<RightClickHandler>();
				rightClickHandler.effectName = item.itemName;
				rightClickHandler.category = "FavoriteShopItems";
			}
		}

		public static void grantAdmin(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Grant Admin";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				showDebugMenu(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (Misc.IsPlayerReal(player))
				{
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
					TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
					component4.text = player.playerUsername ?? "";
					Button component5 = val2.GetComponent<Button>();
					((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
					{
						CloseSelectMenu();
						Networker.Instance.becomeAdminServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), grant: false, forced: false);
						string text = "";
						text = "Made " + player.playerUsername + " an admin";
						Networker.Instance.MessageToHostServerRPC("Admin", text);
					});
				}
			}
		}

		public static void spawnFunctions(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Spawn Functions";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				showDebugMenu(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
			component4.text = "Spawn Enemy";
			Button component5 = val2.GetComponent<Button>();
			((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				spawnEnemy(full, complete, su);
			});
			GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component6 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
			component6.text = "Spawn Scrap";
			Button component7 = val3.GetComponent<Button>();
			((UnityEvent)component7.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				spawnScrap(full, complete, su);
			});
			GameObject val4 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component8 = ((Component)val4.transform.GetChild(0)).GetComponent<TMP_Text>();
			component8.text = "Spawn Shop Items";
			Button component9 = val4.GetComponent<Button>();
			((UnityEvent)component9.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				spawnShopItems(full, complete, su);
			});
			GameObject val5 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component10 = ((Component)val5.transform.GetChild(0)).GetComponent<TMP_Text>();
			component10.text = "Spawn Trap";
			Button component11 = val5.GetComponent<Button>();
			((UnityEvent)component11.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				spawnTrap(full, complete, su);
			});
			if (isSpecial() || ((NetworkBehaviour)StartOfRound.Instance.localPlayerController).IsHost)
			{
				GameObject val6 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component12 = ((Component)val6.transform.GetChild(0)).GetComponent<TMP_Text>();
				component12.text = "Spawn Outside Objects";
				Button component13 = val6.GetComponent<Button>();
				((UnityEvent)component13.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					spawnWorldObject(full, complete, su);
				});
			}
		}

		public static void specialFunctions(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Special Functions";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				showDebugMenu(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
			component4.text = "Play Sound";
			Button component5 = val2.GetComponent<Button>();
			((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				ShowSoundMenu(full, complete, su);
			});
			GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component6 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
			component6.text = "Spawn miniture Enemy";
			Button component7 = val3.GetComponent<Button>();
			((UnityEvent)component7.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				spawnMiniEnemy(full, complete, su);
			});
		}

		public static void playerFunctions(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Player Functions";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				showDebugMenu(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
			component4.text = "Revive Player";
			Button component5 = val2.GetComponent<Button>();
			((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				RevivePlayer(full, complete, su);
			});
			GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component6 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
			component6.text = "Teleport to Player";
			Button component7 = val3.GetComponent<Button>();
			((UnityEvent)component7.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				TeleportPlayer(full, complete, su);
			});
			GameObject val4 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component8 = ((Component)val4.transform.GetChild(0)).GetComponent<TMP_Text>();
			component8.text = "Bring Player";
			Button component9 = val4.GetComponent<Button>();
			((UnityEvent)component9.onClick).AddListener((UnityAction)delegate
			{
				CloseSelectMenu();
				TeleportPlayer(full, complete, su, bring: true);
			});
			if (isSpecial())
			{
				GameObject val5 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component10 = ((Component)val5.transform.GetChild(0)).GetComponent<TMP_Text>();
				component10.text = "Force Suit";
				Button component11 = val5.GetComponent<Button>();
				((UnityEvent)component11.onClick).AddListener((UnityAction)delegate
				{
					CloseSelectMenu();
					ForceSuitPlayerSelector(full, complete, su);
				});
			}
		}

		public static void TeleportPlayer(bool full, bool complete, bool su = false, bool bring = false)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Teleport Player";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				playerFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (!player.isPlayerControlled)
				{
					continue;
				}
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component4.text = player.playerUsername ?? "";
				Button component5 = val2.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					//IL_004b: Unknown result type (might be due to invalid IL or missing references)
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
					if (localPlayerController.isPlayerDead && bring)
					{
						Networker.Instance.TeleportOrBringPlayerToPosServerRPC(((Component)StartOfRound.Instance.spectateCamera).transform.position, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player));
					}
					else
					{
						Networker.Instance.TeleportOrBringPlayerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), bring);
					}
					string text = "";
					text = ((!bring) ? ("Teleported to " + player.playerUsername) : ("Brought " + player.playerUsername + " to you!"));
					Misc.SafeTipMessage("Teleport", text);
				});
			}
		}

		public static void ForceSuitPlayerSelector(bool full, bool complete, bool su = false)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Force Suit";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				playerFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			foreach (PlayerControllerB player in source)
			{
				if (player.isPlayerControlled)
				{
					GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
					TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
					component4.text = player.playerUsername ?? "";
					Button component5 = val2.GetComponent<Button>();
					((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
					{
						ForceSuitSuitSelector(full, complete, player, su);
					});
				}
			}
		}

		public static void ForceSuitSuitSelector(bool full, bool complete, PlayerControllerB players, bool su = false)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Expected O, but got Unknown
			//IL_0284: 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_02b0: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Force Suit";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				playerFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
			foreach (UnlockableSuit suit in Networker.orderedSuits)
			{
				string unlockableName = unlockables[suit.syncedSuitID.Value].unlockableName;
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component4.text = unlockableName ?? "";
				Button component5 = val2.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					Networker.Instance.suitStuffServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, players), suit.syncedSuitID.Value);
				});
			}
			GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
			TMP_Text component6 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
			component6.text = "Refresh Suits";
			((Graphic)component6).color = Color.red;
			Button component7 = val3.GetComponent<Button>();
			((UnityEvent)component7.onClick).AddListener((UnityAction)delegate
			{
				Networker.orderedSuits = (from val4 in Object.FindObjectsOfType<UnlockableSuit>()
					orderby (val4.syncedSuitID.Value >= 0 && val4.syncedSuitID.Value < StartOfRound.Instance.unlockablesList.unlockables.Count) ? StartOfRound.Instance.unlockablesList.unlockables[val4.syncedSuitID.Value].unlockableName : string.Empty
					select val4).ToList();
				CloseSelectMenu();
				ForceSuitSuitSelector(full, complete, players, su);
			});
		}

		public static void RefreshRevives()
		{
			currentStuff.TryGetValue("full", out var value);
			currentStuff.TryGetValue("complete", out var value2);
			currentStuff.TryGetValue("su", out var value3);
			RevivePlayer(value, value2, value3);
		}

		public static void RevivePlayer(bool full, bool complete, bool su = false)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Expected O, but got Unknown
			ReviveOpen = true;
			currentStuff = new Dictionary<string, bool>();
			currentStuff.Add("full", full);
			currentStuff.Add("complete", complete);
			currentStuff.Add("su", su);
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				ReviveOpen = false;
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			TMP_Text component = ((Component)EffectMenu.transform.Find("Panel/Text (TMP)")).GetComponent<TMP_Text>();
			component.text = "Revive Player";
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component2 = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component3 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component3.text = "Back";
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				playerFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<PlayerControllerB> source = StartOfRound.Instance.allPlayerScripts.ToList();
			source = (from x in source
				group x by x.playerUsername into g
				select g.First() into x
				orderby x.playerUsername
				select x).ToList();
			int num = 0;
			foreach (PlayerControllerB player in source)
			{
				if (!player.isPlayerDead)
				{
					continue;
				}
				num++;
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component4 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component4.text = player.playerUsername ?? "";
				Button component5 = val2.GetComponent<Button>();
				((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
				{
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					else
					{
						CloseSelectMenu();
						RevivePlayer(full, complete, su);
					}
					Networker.Instance.RevivePlayerServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player), StartOfRound.Instance.middleOfShipNode.position);
					string text = "";
					text = "Revived " + player.playerUsername;
					Misc.SafeTipMessage("Revival", text);
				});
			}
			if (num == 0)
			{
				GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component6 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
				component6.text = "No Dead Players";
			}
		}

		public static void ShowSelectMenu(bool full, bool complete = false, bool su = false, bool fromSaint = false)
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//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_00f5: Expected O, but got Unknown
			//IL_0210: 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_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_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component2 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component2.text = "Back";
			if (fromSaint)
			{
				component2.text = "Exit";
			}
			if (fromSaint)
			{
				ButtonClickedEvent onClick = component.onClick;
				object obj = <>c.<>9__30_0;
				if (obj == null)
				{
					UnityAction val2 = delegate
					{
						CloseSelectMenu();
					};
					<>c.<>9__30_0 = val2;
					obj = (object)val2;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
			}
			else
			{
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					showDebugMenu(full, complete, su);
				});
			}
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			List<IEffect> ordered = getOrdered(full, complete);
			foreach (IEffect effect in ordered)
			{
				GameObject val3 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component3 = ((Component)val3.transform.GetChild(0)).GetComponent<TMP_Text>();
				FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
				List<string> favorites = favoriteData.Favorites;
				bool flag = favorites.Contains(effect.Name);
				string text = (flag ? "*" : "");
				component3.text = $"{text} {effect.Name} [{effect.Outcome}] {text}";
				((Graphic)component3).color = (flag ? Color.gray : Color.black);
				component3.outlineColor = Color32.op_Implicit(Color.black);
				component3.outlineWidth = 1f;
				if (component3.text.Length > 20)
				{
					component3.fontSize = 12f;
				}
				else
				{
					component3.fontSize = 16f;
				}
				Button component4 = val3.GetComponent<Button>();
				((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
				{
					if (fromSaint)
					{
						CloseSelectMenu();
					}
					else if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					effect.Use();
				});
				RightClickHandler rightClickHandler = val3.AddComponent<RightClickHandler>();
				rightClickHandler.effectName = effect.Name;
				rightClickHandler.category = "Favorites";
				rightClickHandler.full = full;
				rightClickHandler.complete = complete;
			}
		}

		public static void ShowSoundMenu(bool full, bool complete = false, bool su = false)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//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_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Object.Destroy((Object)(object)EffectMenu);
				EffectMenu = null;
			}
			EffectMenu = Object.Instantiate<GameObject>(MysteryDice.NewSelectMenuPrefab);
			Transform val = EffectMenu.transform.Find("Panel/Panel/Scroll View/Viewport/Content");
			Button component = ((Component)EffectMenu.transform.Find("Panel/Exit")).GetComponent<Button>();
			TMP_Text component2 = ((Component)EffectMenu.transform.Find("Panel/Exit/Text (TMP)")).GetComponent<TMP_Text>();
			component2.text = "Back";
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				specialFunctions(full, complete, su);
			});
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			foreach (KeyValuePair<string, AudioClip> entry in MysteryDice.sounds.OrderBy((KeyValuePair<string, AudioClip> x) => x.Key))
			{
				GameObject val2 = Object.Instantiate<GameObject>(MysteryDice.DebugMenuButtonPrefab, val);
				TMP_Text component3 = ((Component)val2.transform.GetChild(0)).GetComponent<TMP_Text>();
				component3.text = entry.Key;
				component3.outlineColor = Color32.op_Implicit(Color.black);
				component3.outlineWidth = 1f;
				if (component3.text.Length > 20)
				{
					component3.fontSize = 12f;
				}
				else
				{
					component3.fontSize = 16f;
				}
				Button component4 = val2.GetComponent<Button>();
				((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
				{
					if (MysteryDice.DebugMenuClosesAfter.Value)
					{
						CloseSelectMenu();
					}
					Networker.Instance.PlaySoundServerRPC(entry.Key);
				});
			}
		}

		public static void ToggleFavorite(IEffect effect)
		{
			FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
			if (favoriteData.Favorites.Contains(effect.Name))
			{
				favoriteData.Favorites.Remove(effect.Name);
			}
			else
			{
				favoriteData.Favorites.Add(effect.Name);
			}
			FavoriteEffectManager.SaveFavorites(favoriteData);
		}

		public static void CloseSelectMenu()
		{
			if ((Object)(object)EffectMenu != (Object)null)
			{
				Cursor.visible = false;
				Cursor.lockState = (CursorLockMode)1;
				Object.Destroy((Object)(object)EffectMenu);
				currentStuff = new Dictionary<string, bool>();
				ReviveOpen = false;
			}
		}
	}
	public class RightClickHandler : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		public string effectName;

		public string category;

		public bool full;

		public bool complete;

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 1)
			{
				FavoriteEffectManager.FavoriteData favoriteData = FavoriteEffectManager.LoadFavorites();
				switch (category)
				{
				case "Favorites":
					ToggleFavorite(effectName, favoriteData.Favorites);
					break;
				case "FavoriteEnemies":
					ToggleFavorite(effectName, favoriteData.FavoriteEnemies);
					break;
				case "FavoriteTraps":
					ToggleFavorite(effectName, favoriteData.FavoriteTraps);
					break;
				case "FavoriteScraps":
					ToggleFavorite(effectName, favoriteData.FavoriteScraps);
					break;
				case "FavoriteShopItems":
					ToggleFavorite(effectName, favoriteData.FavoriteShopItems);
					break;
				}
				FavoriteEffectManager.SaveFavorites(favoriteData);
				SelectEffect.CloseSelectMenu();
				switch (category)
				{
				case "Favorites":
					SelectEffect.ShowSelectMenu(full, complete);
					break;
				case "FavoriteEnemies":
					SelectEffect.spawnEnemy(full, complete);
					break;
				case "FavoriteTraps":
					SelectEffect.spawnTrap(full, complete);
					break;
				case "FavoriteScraps":
					SelectEffect.spawnScrap(full, complete);
					break;
				case "FavoriteShopItems":
					SelectEffect.spawnShopItems(full, complete);
					break;
				}
			}
		}

		private void ToggleFavorite(string name, List<string> favorites)
		{
			if (favorites.Contains(name))
			{
				favorites.Remove(name);
			}
			else
			{
				favorites.Add(name);
			}
		}
	}
	public static class FavoriteEffectManager
	{
		public class FavoriteData
		{
			public List<string> Favorites { get; set; } = new List<string>();

			public List<string> FavoriteEnemies { get; set; } = new List<string>();

			public List<string> FavoriteTraps { get; set; } = new List<string>();

			public List<string> FavoriteScraps { get; set; } = new List<string>();

			public List<string> FavoriteShopItems { get; set; } = new List<string>();

			public List<string> FavoriteItems { get; set; } = new List<string>();
		}

		private static readonly string directoryPath = Path.Combine(Application.persistentDataPath, "EmergencyDice");

		private static readonly string filePath = Path.Combine(directoryPath, "Favorites.json");

		public static FavoriteData LoadFavorites()
		{
			if (!Directory.Exists(directoryPath))
			{
				Directory.CreateDirectory(directoryPath);
			}
			if (!File.Exists(filePath))
			{
				Debug.LogWarning((object)("Favorites file not found at " + filePath + ". Returning empty data."));
				return new FavoriteData();
			}
			try
			{
				string text = File.ReadAllText(filePath);
				return JsonConvert.DeserializeObject<FavoriteData>(text) ?? new FavoriteData();
			}
			catch
			{
				Debug.LogError((object)("Failed to load favorites from " + filePath + ". Returning empty data."));
				return new FavoriteData();
			}
		}

		public static void SaveFavorites(FavoriteData favorites)
		{
			if (!Directory.Exists(directoryPath))
			{
				Directory.CreateDirectory(directoryPath);
			}
			try
			{
				string contents = JsonConvert.SerializeObject((object)favorites, (Formatting)1);
				File.WriteAllText(filePath, contents);
				Debug.Log((object)("Favorites successfully saved to " + filePath));
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Failed to save favorites to " + filePath + ". Error: " + ex.Message));
			}
		}
	}
	internal class ShipTurret : IEffect
	{
		public static int MaxTurretsToSpawn = 4;

		public string Name => "Ship Turret";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Turret spawned near the ship!";

		public void Use()
		{
			Networker.Instance.ShipTurretServerRPC();
		}

		public static void SpawnTurretsShip(int amount)
		{
			//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_006a: 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_0079: 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_008c: 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_00b7: 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)
			//IL_0048: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("CatwalkShip");
			Transform val2 = ((!((Object)(object)val == (Object)null)) ? val.transform : StartOfRound.Instance.middleOfShipNode);
			for (int i = 0; i < amount; i++)
			{
				Vector3 val3 = val2.position;
				if ((Object)(object)val == (Object)null)
				{
					val3 += new Vector3(-8f, 0.5f, 0f);
				}
				val3 = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(val3, 8f, default(NavMeshHit));
				GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.SpawnableTurret.prefabToSpawn, val3, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
				val4.GetComponent<NetworkObject>().Spawn(true);
			}
		}
	}
	internal class Shotgun : IEffect
	{
		public string Name => "Shotgun";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Spawning a shotgun!";

		public void Use()
		{
			Networker.Instance.ShotgunServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void SpawnShotgun(int playerID)
		{
			//IL_028a: 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_0303: 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)
			try
			{
				List<Item> list = Resources.FindObjectsOfTypeAll<Item>().ToList();
				Item val = ((IEnumerable<Item>)list).LastOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name.Equals("Shotgun") && (Object)(object)item.spawnPrefab != (Object)null && item.spawnPrefab.GetComponents<Component>().Length == 10));
				Item val2 = ((IEnumerable<Item>)list).LastOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name.Equals("GunAmmo") && (Object)(object)item.spawnPrefab != (Object)null && item.spawnPrefab.GetComponents<Component>().Length == 7));
				if ((Object)(object)val == (Object)null)
				{
					List<Item> list2 = list.FindAll((Item item) => ((Object)item).name.Equals("Shotgun"));
					int num = 0;
					foreach (Item item in list2)
					{
						num++;
						List<Component> list3 = item.spawnPrefab.GetComponents<Component>().ToList();
						foreach (Component item2 in list3)
						{
							MysteryDice.CustomLogger.LogWarning((object)("Shotgun " + num + ": " + ((object)item2).GetType().Name));
						}
					}
					val = list.Last((Item item) => ((Object)item).name.Equals("Shotgun"));
				}
				if ((Object)(object)val2 == (Object)null)
				{
					List<Item> list4 = list.FindAll((Item item) => ((Object)item).name.Equals("GunAmmo"));
					int num2 = 0;
					foreach (Item item3 in list4)
					{
						num2++;
						List<Component> list5 = item3.spawnPrefab.GetComponents<Component>().ToList();
						foreach (Component item4 in list5)
						{
							MysteryDice.CustomLogger.LogWarning((object)("Ammo " + num2 + ": " + ((object)item4).GetType().Name));
						}
					}
					val2 = list.Last((Item item) => ((Object)item).name.Equals("GunAmmo"));
				}
				GameObject val3 = Object.Instantiate<GameObject>(val.spawnPrefab, ((Component)Misc.GetPlayerByUserID(playerID)).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
				val3.GetComponent<GrabbableObject>().fallTime = 0f;
				NetworkObject component = val3.GetComponent<NetworkObject>();
				component.Spawn(false);
				CullFactorySoftCompat.RefreshGrabbableObjectPosition(val3.GetComponent<GrabbableObject>());
				val3.GetComponent<GrabbableObject>().EnablePhysics(true);
				int num3 = Random.Range(2, 6);
				for (int num4 = 0; num4 < num3; num4++)
				{
					GameObject val4 = Object.Instantiate<GameObject>(val2.spawnPrefab, ((Component)Misc.GetPlayerByUserID(playerID)).transform.position, Quaternion.identity, RoundManager.Instance.playersManager.propsContainer);
					val4.GetComponent<GrabbableObject>().fallTime = 0f;
					NetworkObject component2 = val4.GetComponent<NetworkObject>();
					component2.Spawn(false);
					CullFactorySoftCompat.RefreshGrabbableObjectPosition(val4.GetComponent<GrabbableObject>());
					val3.GetComponent<GrabbableObject>().EnablePhysics(true);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)ex);
			}
		}
	}
	internal class SilentMine : IEffect
	{
		public string Name => "Silent mine";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Mines are silent and invisible";

		public void Use()
		{
			Networker.Instance.SilenceMinesServerRPC();
		}

		public static IEnumerator SilenceAllMines(bool isServer)
		{
			if (isServer)
			{
				MineOverflow.SpawnMoreMines(10);
			}
			yield return (object)new WaitForSeconds(5f);
			Landmine[] landmines = Object.FindObjectsOfType<Landmine>();
			Landmine[] array = landmines;
			foreach (Landmine mine in array)
			{
				mine.mineAudio.volume = 0f;
				mine.mineAnimator.StopPlayback();
				Renderer[] renderers = ((Component)mine).GetComponentsInChildren<Renderer>();
				Renderer[] array2 = renderers;
				foreach (Renderer renderer in array2)
				{
					Object.Destroy((Object)(object)renderer);
				}
			}
		}
	}
	internal class SilentTP : IEffect
	{
		public object TeleporterTrapScr;

		public string Name => "Silent Teleporter Traps";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Teleporter Traps are invisible";

		public void Use()
		{
			Networker.Instance.SilenceTPServerRPC();
		}

		public static IEnumerator SilenceAllTP(bool isServer)
		{
			if (isServer)
			{
				TPTraps.SpawnTeleporterTraps(10);
			}
			yield return (object)new WaitForSeconds(5f);
			IEnumerable<Component> landmines = from c in Object.FindObjectsOfType<Component>()
				where ((object)c).GetType().Name == "TeleporterTrap"
				select c;
			foreach (Component mine in landmines)
			{
				Renderer[] renderers = mine.GetComponentsInChildren<Renderer>();
				Renderer[] array = renderers;
				foreach (Renderer renderer in array)
				{
					Object.Destroy((Object)(object)renderer);
				}
			}
		}
	}
	internal class SkyFan : IEffect
	{
		public static int MinMinesToSpawn = 1;

		public static int MaxMinesToSpawn = 1;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Sky Fan";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Suck or Blow, either way you're gonna go";

		public void Use()
		{
			Networker.Instance.SkyFanServerRPC();
		}

		public unsafe static void SpawnSkyFan(float positionOffsetRadius = 5f)
		{
			//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_00bd: 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_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_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_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_0102: 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_0259: 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_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_014a: 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_0180: 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_01a7: 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_0209: Unknown result type (might be due to invalid IL or missing references)
			int num = 1;
			int num2 = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num3 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num2 < num)
			{
				for (int i = 0; i < count; i++)
				{
					if (num2 >= num)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num3; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.Fan.prefabToSpawn, point + new Vector3(0f, 250f, 0f), Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								NetworkObject component = val4.GetComponent<NetworkObject>();
								component.Spawn(true);
								Networker.Instance.setSuctionServerRPC(component.NetworkObjectId);
								num2++;
								Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3(45f, 75f, 45f), Quaternion.Euler(90f, 0f, 0f));
								Networker.Instance.removeShadowsClientRPC(component.NetworkObjectId);
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static void setSuck(GameObject fan)
		{
			IndustrialFan component = fan.GetComponent<IndustrialFan>();
			component.pushForce *= -0.06f;
			component.suctionForce *= 0.06f;
			component.rotationSpeed *= 0.15f;
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class SmolCrane : IEffect
	{
		public static int MinMinesToSpawn = 1;

		public static int MaxMinesToSpawn = 1;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Smol Crane";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "it smol";

		public void Use()
		{
			Networker.Instance.SpawnSmolCraneServerRPC();
		}

		public unsafe static void SpawnSmolCrane(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: 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_0212: 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_0131: 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_0167: 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_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(DynamicTrapEffect.getTrap("Autonomous Crane").prefab, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								NetworkObject component = val4.GetComponent<NetworkObject>();
								component.Spawn(true);
								num++;
								Networker.Instance.setSizeClientRPC(component.NetworkObjectId, new Vector3(0.5f, 0.5f, 0.5f));
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class SpawnCruiser : IEffect
	{
		public string Name => "Free Cruiser";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Vroom Vroom";

		public void Use()
		{
			Networker.Instance.FreeCruiserServerRPC();
		}

		public static void Spawn(bool temporary = false)
		{
			//IL_001b: 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_0043: 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_0048: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			Terminal val = Object.FindObjectOfType<Terminal>();
			Vector3 val2 = (temporary ? (StartOfRound.Instance.middleOfShipNode.position + new Vector3((float)Random.Range(-100, 100), (float)Random.Range(50, 100), (float)Random.Range(-100, 100))) : Vector3.zero);
			GameObject val3 = Object.Instantiate<GameObject>(val.buyableVehicles[0].vehiclePrefab, val2, Quaternion.identity, RoundManager.Instance.VehiclesContainer);
			NetworkObject component = val3.GetComponent<NetworkObject>();
			component.Spawn(temporary);
			VehicleController component2 = val3.GetComponent<VehicleController>();
			if (temporary && Object.op_Implicit((Object)(object)component2))
			{
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(explodeCar(component2, component));
			}
		}

		public static IEnumerator explodeCar(VehicleController vehicleController, NetworkObject netObj)
		{
			yield return (object)new WaitForSeconds(5f);
			vehicleController.DestroyCarServerRpc(0);
			yield return (object)new WaitForSeconds(5f);
			netObj.Despawn(true);
		}
	}
	internal class SpecialDetonate : IEffect
	{
		public string Name => "Special Detonate";

		public EffectType Outcome => EffectType.Penalty;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Kaboom";

		public void Use()
		{
			Networker.Instance.SpecialDetonateServerRPC();
		}
	}
	internal class GalDetonate : GalEffect, IEffect
	{
		public string Name => "Gal Detonate";

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Kaboom";

		public EffectType RealOutcome => EffectType.Awful;

		public EffectType NoGalOutcome => EffectType.GalOnly;

		public void Use()
		{
			Networker.Instance.GalDetonateServerRPC();
		}
	}
	internal class SpeedUp : IEffect
	{
		public string Name => "$Speed Up Time";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Hehe Time go brrr";

		public void Use()
		{
			Networker.Instance.TimeScaleServerRPC();
		}
	}
	internal class SpicyNuggies : IEffect
	{
		public string Name => "Spicy Nuggies";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Spicy Nuggies!!!";

		public void Use()
		{
			Networker.Instance.spicyNuggiesServerRPC();
		}

		public static void Spawn()
		{
			//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_003e: 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_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)
			int num = Random.Range(2, 7);
			if (GetEnemies.Masked != null)
			{
				for (int i = 0; i < num; i++)
				{
					Vector3 position = StartOfRound.Instance.middleOfShipNode.position;
					GameObject val = Object.Instantiate<GameObject>(GetEnemies.Masked.enemyType.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
					val.GetComponentInChildren<NetworkObject>().Spawn(true);
					RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
					NetworkObjectReference val2 = NetworkObjectReference.op_Implicit(val.GetComponentInChildren<NetworkObject>());
				}
			}
		}
	}
	internal class SpikeOverflowOutside : IEffect
	{
		public static int MinMinesToSpawn = 3;

		public static int MaxMinesToSpawn = 7;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Spike overflow outside";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Spike Traps spawned outside!";

		public void Use()
		{
			Networker.Instance.SpikeOverflowOutsideServerRPC();
		}

		public unsafe static void SpawnSpikeOutside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_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_014c: 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_017f: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.SpawnableSpikeTrap.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								val4.GetComponent<NetworkObject>().Spawn(true);
								num++;
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class SuperFlinger : IEffect
	{
		private static readonly int Black = Shader.PropertyToID("Black");

		public string Name => "Super Flinger";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE";

		public void Use()
		{
			Networker.Instance.SuperFlingerServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, Misc.GetRandomAlivePlayer()));
		}

		public static void spawnFlinger(int playerId)
		{
			//IL_001d: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerId);
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.Horse.enemyType.enemyPrefab, ((Component)playerByUserID).transform.position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			Networker.Instance.setHorseStuffServerRPC(val.GetComponent<NetworkObject>().NetworkObjectId, 1);
		}

		public static void horseStuff(GameObject obj, int rand1, int rand2, int rand3)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				obj.GetComponent<HorseAI>().launchForceIndex = 2;
				HorseAI component = obj.GetComponent<HorseAI>();
				component.launchForcesPerLevel = new float[3] { 20f, 30f, 100f };
				((Renderer)obj.GetComponents<SkinnedMeshRenderer>()[0]).materials[1].SetColor("Red", Color.red);
			}
			catch
			{
			}
		}
	}
	internal class SuperScrapJackpot : GalEffect, IEffect
	{
		public string Name => "Super Scrap jackpot";

		public EffectType Outcome => MysteryDice.DisableGal.Value ? NoGalOutcome : RealOutcome;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Spawning A ton of scrap!";

		public EffectType RealOutcome => EffectType.Great;

		public EffectType NoGalOutcome => EffectType.Great;

		public void Use()
		{
			Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(8, 12));
		}
	}
	internal class Swap : IEffect
	{
		public string Name => "Swap";

		public EffectType Outcome => EffectType.Mixed;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Swapping two players!";

		public void Use()
		{
			Networker.Instance.SwapPlayersServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void SwapPlayers(int p1ID, int p2ID)
		{
			//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_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_00c2: 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)
			PlayerControllerB val = null;
			PlayerControllerB val2 = null;
			val = StartOfRound.Instance.allPlayerScripts[p1ID];
			val2 = StartOfRound.Instance.allPlayerScripts[p2ID];
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
			{
				Vector3 position = ((Component)val).transform.position;
				Vector3 position2 = ((Component)val2).transform.position;
				bool isInElevator = val.isInElevator;
				bool isInHangarShipRoom = val.isInHangarShipRoom;
				bool isInsideFactory = val.isInsideFactory;
				val.isInElevator = val2.isInElevator;
				val.isInHangarShipRoom = val2.isInHangarShipRoom;
				val.isInsideFactory = val2.isInsideFactory;
				val2.isInElevator = isInElevator;
				val2.isInHangarShipRoom = isInHangarShipRoom;
				val2.isInsideFactory = isInsideFactory;
				val.beamOutParticle.Play();
				val2.beamOutParticle.Play();
				val.TeleportPlayer(position2, false, 0f, false, true);
				val2.TeleportPlayer(position, false, 0f, false, true);
			}
		}
	}
	internal class TakeySmol : IEffect
	{
		public string Name => "Takey Plushies";

		public EffectType Outcome => EffectType.Good;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "What do they do?";

		public void Use()
		{
			//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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), Random.Range(3, 7), "takey");
		}
	}
	internal class TargetPractice : IEffect
	{
		public string Name => "Target Practice";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "You are now a target!";

		public void Use()
		{
			Networker.Instance.targetPracticeServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}
	}
	internal class TarotCards : IEffect
	{
		public string Name => "Tarot Cards";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "A different kind of gambling!";

		public void Use()
		{
			Networker.Instance.TarotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController));
		}

		public static void TarotScrap(int userID)
		{
			//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_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_0143: 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)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(userID);
			List<Item> source = Resources.FindObjectsOfTypeAll<Item>().ToList();
			Item item = ((IEnumerable<Item>)source).LastOrDefault((Func<Item, bool>)((Item val2) => ((Object)val2).name.Equals("TarrotCard") && (Object)(object)val2.spawnPrefab != (Object)null));
			RoundManager instance = RoundManager.Instance;
			List<Item> list = new List<Item>();
			List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
			List<int> list3 = new List<int>();
			List<float> list4 = new List<float>();
			list.Add(item);
			foreach (Item item2 in list)
			{
				GameObject val = Object.Instantiate<GameObject>(item2.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
				component.fallTime = 0f;
				component.scrapValue = (int)((float)Random.Range(item2.minValue, item2.maxValue) * instance.scrapValueMultiplier);
				list3.Add(component.scrapValue);
				list4.Add(component.itemProperties.weight);
				NetworkObject component2 = val.GetComponent<NetworkObject>();
				component2.Spawn(false);
				CullFactorySoftCompat.RefreshGrabbableObjectPosition(val.GetComponent<GrabbableObject>());
				component.FallToGround(false, true, ((Component)playerByUserID).transform.position);
				list2.Add(NetworkObjectReference.op_Implicit(component2));
			}
			((MonoBehaviour)instance).StartCoroutine(DelayedSync(instance, list2.ToArray(), list3.ToArray(), list4.ToArray()));
		}

		public static IEnumerator DelayedSync(RoundManager RM, NetworkObjectReference[] netObjs, int[] scrapValues, float[] scrapWeights)
		{
			yield return (object)new WaitForSeconds(3f);
			RM.SyncScrapValuesClientRpc(netObjs, scrapValues);
			Networker.Instance.SyncItemWeightsClientRPC(netObjs, scrapWeights);
		}
	}
	internal class TeleportInside : IEffect
	{
		public string Name => "Inside teleport";

		public EffectType Outcome => EffectType.Bad;

		public bool IsNegative => true;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Teleported inside";

		public void Use()
		{
			//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_0047: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = RoundManager.Instance.insideAINodes[Random.Range(0, RoundManager.Instance.insideAINodes.Length)].transform.position;
			Networker.Instance.TeleportInsideServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController), position);
		}

		public static void TeleportPlayerInside(int clientID, Vector3 teleportPos)
		{
			//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_0069: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = null;
			val = Misc.GetPlayerByUserID(clientID);
			if (!((Object)(object)val == (Object)null))
			{
				if (Object.op_Implicit((Object)(object)Object.FindObjectOfType<AudioReverbPresets>()))
				{
					Object.FindObjectOfType<AudioReverbPresets>().audioPresets[2].ChangeAudioReverbForPlayer(val);
				}
				val.isInElevator = false;
				val.isInHangarShipRoom = false;
				val.isInsideFactory = true;
				val.averageVelocity = 0f;
				val.velocityLastFrame = Vector3.zero;
				val.TeleportPlayer(teleportPos, false, 0f, false, true);
				val.beamOutParticle.Play();
				if ((Object)(object)val == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
				}
			}
		}
	}
	internal class TerminalLockout : IEffect
	{
		public static float DrunkTimer;

		public string Name => "Terminal Lockout";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "Where did the terminal go?";

		public void Use()
		{
		}
	}
	internal class TheRumbling : IEffect
	{
		public string Name => "The Rumbling";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => false;

		public string Tooltip => "If a tree squishes you in the forest, will you make a sound?";

		public void Use()
		{
			int amount = Random.Range(10, 15);
			if (GetEnemies.RedwoodTitan != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.RedwoodTitan, amount, isInside: false);
				Networker.Instance.PlaySoundServerRPC("aot");
			}
		}
	}
	internal class ThreesCompany : IEffect
	{
		public string Name => "Three`s Company";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Uh Oh Oh Oh";

		public void Use()
		{
			int roll = -1;
			string playerUsername = StartOfRound.Instance.localPlayerController.playerUsername;
			IEffect effect = (from _ in DieBehaviour.AllowedEffects.ToList()
				orderby Random.value
				select _).First();
			MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect in Three`s Company: " + effect.Name));
			effect.Use();
			Networker.Instance.LogEffectsToOwnerServerRPC(playerUsername, effect.Name, roll);
			IEffect effect2 = (from _ in DieBehaviour.AllowedEffects.ToList()
				orderby Random.value
				select _).First();
			MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect in Three`s Company: " + effect2.Name));
			effect2.Use();
			Networker.Instance.LogEffectsToOwnerServerRPC(playerUsername, effect2.Name, roll);
			IEffect effect3 = (from _ in DieBehaviour.AllowedEffects.ToList()
				orderby Random.value
				select _).First();
			MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect in Three`s Company: " + effect3.Name));
			effect3.Use();
			Networker.Instance.LogEffectsToOwnerServerRPC(playerUsername, effect3.Name, roll);
		}
	}
	internal class Tornado : IEffect
	{
		public string Name => "Tornado";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "It Spin";

		public void Use()
		{
			int amount = Random.Range(1, 3);
			if (GetEnemies.Tornado != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Tornado, amount, isInside: false);
			}
		}
	}
	internal class TpOverflowOutside : IEffect
	{
		public static int MinMinesToSpawn = 10;

		public static int MaxMinesToSpawn = 25;

		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "TP overflow outside";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "TP Traps spawned outside!";

		public void Use()
		{
			Networker.Instance.TPOverflowOutsideServerRPC();
		}

		public unsafe static void SpawnTPOutside(int MinesToSpawn, float positionOffsetRadius = 5f)
		{
			//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_00b8: 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_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_00c3: 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_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_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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_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_014c: 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_017f: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			int num2 = 100;
			Vector3 val = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int i = 0; i < count; i++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int j = 0; j < num2; j++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val2 = position + val;
						if (Physics.Raycast(val2 + Vector3.up * 10f, Vector3.down, ref val3, 20f))
						{
							Vector3 point = ((RaycastHit)(ref val3)).point;
							if (GetShortestDistanceSqr(point, allPositions) >= 1f)
							{
								flag = true;
								GameObject val4 = Object.Instantiate<GameObject>(GetEnemies.SpawnableTP.prefabToSpawn, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
								allPositions.Add(point);
								val4.transform.eulerAngles = new Vector3(val4.transform.eulerAngles.x, (float)Random.Range(0, 360), val4.transform.eulerAngles.z);
								val4.GetComponent<NetworkObject>().Spawn(true);
								num++;
							}
						}
					}
					if (!flag)
					{
						Vector3 val5 = position;
						Debug.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val5))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class TPTraps : IEffect
	{
		public static int MaxMinesToSpawn = 30;

		public string Name => "TP Traps";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "More Teleporter Traps spawned inside!";

		public void Use()
		{
			Networker.Instance.TPOverflowServerRPC();
		}

		public static void SpawnTeleporterTraps(int amount)
		{
			//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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//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_0168: 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_0186: 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_01b9: 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)
			MysteryDice.CustomLogger.LogError((object)("Spawn TP Traps called with: " + amount));
			if ((Object)(object)RoundManager.Instance == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"RoundManager.Instance is null.");
				return;
			}
			if (RoundManager.Instance.insideAINodes == null)
			{
				MysteryDice.CustomLogger.LogError((object)"RoundManager.Instance.insideAINodes is null.");
				return;
			}
			if (GetEnemies.SpawnableTP == null)
			{
				MysteryDice.CustomLogger.LogError((object)"GetEnemies.SpawnableTP is null.");
				return;
			}
			if ((Object)(object)GetEnemies.SpawnableTP.prefabToSpawn == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"GetEnemies.SpawnableTP.prefabToSpawn is null.");
				return;
			}
			if ((Object)(object)RoundManager.Instance.mapPropsContainer == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"RoundManager.Instance.mapPropsContainer is null.");
				return;
			}
			List<Vector3> list = new List<Vector3>();
			int num = 0;
			GameObject[] insideAINodes = RoundManager.Instance.insideAINodes;
			foreach (GameObject val in insideAINodes)
			{
				Vector3 position = val.transform.position;
				if (num > amount)
				{
					break;
				}
				Vector3 randomNavMeshPositionInRadiusSpherical = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(position, 10f, default(NavMeshHit));
				if (!(GetShortestDistanceSqr(randomNavMeshPositionInRadiusSpherical, list) < 1f))
				{
					GameObject val2 = Object.Instantiate<GameObject>(GetEnemies.SpawnableTP.prefabToSpawn, randomNavMeshPositionInRadiusSpherical, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
					list.Add(randomNavMeshPositionInRadiusSpherical);
					val2.transform.eulerAngles = new Vector3(val2.transform.eulerAngles.x, (float)Random.Range(0, 360), val2.transform.eulerAngles.z);
					val2.GetComponent<NetworkObject>().Spawn(true);
					num++;
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class TulipBombers : IEffect
	{
		private static List<Vector3> allPositions = new List<Vector3>();

		public string Name => "Tulip Bombers";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Tulip Bombers";

		public void Use()
		{
			Networker.Instance.doTulipBomberServerRPC(2);
		}

		public unsafe static void spawnAttachedEnemyCombo(int MinesToSpawn, string spawnableEnemy, string spawnableTrap, bool isOutside, Vector3 trapOffset = default(Vector3), float positionOffsetRadius = 5f, Vector3 sizeOfTrap = default(Vector3), bool matchSize = false, bool targetRandom = false)
		{
			//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_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_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_0137: 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_014b: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: 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_0199: 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_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)
			//IL_01c8: 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_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_0211: 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_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_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: 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_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: 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)
			int num = 0;
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			List<GameObject> list = RoundManager.Instance.outsideAINodes.ToList();
			if (!isOutside)
			{
				list = RoundManager.Instance.insideAINodes.ToList();
			}
			int count = list.Count;
			if (count == 0)
			{
				return;
			}
			EnemyType val = (from x in GetEnemies.allEnemies.ToList()
				where x.enemyName == spawnableEnemy
				select x).First();
			trap trap = (from x in Misc.getAllTraps()
				where x.name == spawnableTrap
				select x).First();
			int num2 = 100;
			Vector3 val2 = default(Vector3);
			RaycastHit val4 = default(RaycastHit);
			while (num < MinesToSpawn)
			{
				for (int num3 = 0; num3 < count; num3++)
				{
					if (num >= MinesToSpawn)
					{
						break;
					}
					Vector3 position = list[Random.Range(0, count)].transform.position;
					bool flag = false;
					for (int num4 = 0; num4 < num2; num4++)
					{
						if (flag)
						{
							break;
						}
						((Vector3)(ref val2))..ctor((float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius, 0f, (float)(random.NextDouble() * 2.0 - 1.0) * positionOffsetRadius);
						Vector3 val3 = position + val2;
						if (!Physics.Raycast(val3 + Vector3.up * 10f, Vector3.down, ref val4, 20f))
						{
							continue;
						}
						Vector3 point = ((RaycastHit)(ref val4)).point;
						if (!(GetShortestDistanceSqr(point, allPositions) >= 1f))
						{
							continue;
						}
						flag = true;
						GameObject val5 = Object.Instantiate<GameObject>(val.enemyPrefab, point, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
						Vector3 val6 = val5.transform.position;
						if (trapOffset != default(Vector3))
						{
							val6 += trapOffset;
						}
						GameObject val7 = Object.Instantiate<GameObject>(trap.prefab, val6, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
						allPositions.Add(point);
						NetworkObject component = val7.GetComponent<NetworkObject>();
						NetworkObject component2 = val5.GetComponent<NetworkObject>();
						if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
						{
							component.Spawn(true);
							component2.Spawn(true);
							RoundManager.Instance.SpawnedEnemies.Add(val5.GetComponent<EnemyAI>());
							if (sizeOfTrap != default(Vector3) || matchSize)
							{
								if (matchSize)
								{
									Networker.Instance.MatchSizeClientRPC(component.NetworkObjectId, component2.NetworkObjectId);
								}
								else
								{
									Networker.Instance.setSizeClientRPC(component.NetworkObjectId, sizeOfTrap);
								}
							}
							if (targetRandom)
							{
								val5.AddComponent<TargetRandomPlayer>();
							}
							val7.transform.SetParent(val5.transform);
							num++;
							Networker.Instance.ScanSphereDisableClientRPC(component.NetworkObjectId);
							continue;
						}
						Object.Destroy((Object)(object)val7);
						Object.Destroy((Object)(object)val5);
						MysteryDice.CustomLogger.LogWarning((object)"TB/MS Spawn aborted: missing NetworkObject, EnemyAI or Trap.");
						return;
					}
					if (!flag)
					{
						ManualLogSource customLogger = MysteryDice.CustomLogger;
						Vector3 val8 = position;
						customLogger.LogWarning((object)("Could not find a valid position for mine at spawn point: " + ((object)(*(Vector3*)(&val8))/*cast due to .constrained prefix*/).ToString()));
					}
				}
			}
		}

		public static float GetShortestDistanceSqr(Vector3 position, List<Vector3> positions)
		{
			//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_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_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)
			float num = float.MaxValue;
			foreach (Vector3 position2 in positions)
			{
				Vector3 val = position - position2;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
				}
			}
			return num;
		}
	}
	internal class TulipTrapeze : IEffect
	{
		public string Name => "Tulip Trapeze";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Hope you like flying";

		public void Use()
		{
			Networker.Instance.TulipTrapeezeServerRPC();
		}

		public static void spawn()
		{
			//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_00dd: 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_013b: 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_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_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_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_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)
			bool flag = false;
			RoundManager instance = RoundManager.Instance;
			int num = Random.Range(10, 16);
			if (GetEnemies.Tulip != null)
			{
				PlayerControllerB randomAlivePlayer = Misc.GetRandomAlivePlayer();
				Networker.Instance.TulipTrapeezeMessageServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, randomAlivePlayer));
				randomAlivePlayer.DropAllHeldItemsAndSyncNonexact();
				float num2 = 2f;
				if (!RoundManager.Instance.currentLevel.Enemies.Contains(GetEnemies.Tulip))
				{
					RoundManager.Instance.currentLevel.Enemies.Add(GetEnemies.Tulip);
					flag = true;
				}
				EntranceTeleport val = ((IEnumerable<EntranceTeleport>)Object.FindObjectsOfType<EntranceTeleport>()).FirstOrDefault((Func<EntranceTeleport, bool>)((EntranceTeleport e) => e.entranceId == 0 && e.isEntranceToBuilding));
				Vector3 position = val.entrancePoint.position;
				if (Object.op_Implicit((Object)(object)val))
				{
					randomAlivePlayer.TeleportPlayer(position, false, 0f, false, true);
				}
				Vector3 val2 = default(Vector3);
				for (int num3 = 0; num3 < num; num3++)
				{
					float num4 = (float)num3 * MathF.PI * 2f / (float)num;
					((Vector3)(ref val2))..ctor(Mathf.Cos(num4) * num2, ((Component)randomAlivePlayer).transform.position.y + 0.25f, Mathf.Sin(num4) * num2);
					val2 += ((Component)randomAlivePlayer).transform.position;
					Vector3 val3 = ((Component)randomAlivePlayer).transform.position - val2;
					Quaternion val4 = Quaternion.LookRotation(val3);
					GameObject val5 = Object.Instantiate<GameObject>(GetEnemies.Tulip.enemyType.enemyPrefab, val2, val4);
					val5.GetComponentInChildren<NetworkObject>().Spawn(true);
					instance.SpawnedEnemies.Add(val5.GetComponent<EnemyAI>());
				}
				if (flag)
				{
					RoundManager.Instance.currentLevel.Enemies.Remove(GetEnemies.Tulip);
					flag = false;
				}
			}
		}
	}
	internal class TurnOffLights : IEffect
	{
		public string Name => "Lights off";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Turns off all lights";

		public void Use()
		{
			Networker.Instance.TurnOffAllLightsServerRPC();
		}
	}
	internal class TurretHell : IEffect
	{
		public static int MaxTurretsToSpawn = 6;

		public string Name => "Turret hell";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "More turrets spawned inside!";

		public void Use()
		{
			Networker.Instance.TuretHellServerRPC();
		}

		public static void SpawnTurrets(int amount)
		{
			//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_003c: 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_004b: 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_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_0089: 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)
			int num = 0;
			GameObject[] insideAINodes = RoundManager.Instance.insideAINodes;
			foreach (GameObject val in insideAINodes)
			{
				Vector3 position = val.transform.position;
				if (num > amount)
				{
					break;
				}
				position = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(position, 10f, default(NavMeshHit));
				GameObject val2 = Object.Instantiate<GameObject>(GetEnemies.SpawnableTurret.prefabToSpawn, position, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				val2.transform.eulerAngles = new Vector3(val2.transform.eulerAngles.x, (float)Random.Range(0, 360), val2.transform.eulerAngles.z);
				val2.GetComponent<NetworkObject>().Spawn(true);
				num++;
			}
		}
	}
	internal class Unkillable : IEffect
	{
		public string Name => "Unkillable";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "YAY";

		public void Use()
		{
			Networker.Instance.UnkillableServerRpc(Misc.GetRandomPlayerID());
		}
	}
	internal class UrchinIndoors : IEffect
	{
		public string Name => "Indoor Urchins";

		public EffectType Outcome => EffectType.Bad;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Spikey boyos, but inside!";

		public void Use()
		{
			int amount = Random.Range(2, 4);
			if (GetEnemies.Urchin != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Urchin, amount, isInside: true);
			}
		}
	}
	internal class WhereDidMyFriendsGo : IEffect
	{
		public static List<PlayerControllerB> hiddenPlayers = new List<PlayerControllerB>();

		public string Name => "Where Did My Friends Go?";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Where did they go?";

		public void Use()
		{
			Networker.Instance.WhereGoServerRPC(Misc.GetRandomPlayerID());
		}

		public static void TurnPlayerInvisible(PlayerControllerB player, bool value)
		{
			GameObject gameObject = ((Component)((Component)player).gameObject.transform.Find("ScavengerModel")).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				MysteryDice.CustomLogger.LogError((object)"ScavengerModel not found");
				return;
			}
			((Component)gameObject.transform.Find("LOD1")).gameObject.SetActive(!value);
			((Component)gameObject.transform.Find("LOD2")).gameObject.SetActive(!value);
			((Component)gameObject.transform.Find("LOD3")).gameObject.SetActive(!value);
			((Component)player.playerBadgeMesh).gameObject.SetActive(value);
		}

		public static void whereTheyGo(int userID)
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded || (Object)(object)StartOfRound.Instance.localPlayerController != (Object)(object)StartOfRound.Instance.allPlayerScripts[userID])
			{
				return;
			}
			invisiblePlayerController invisiblePlayerController2 = ((Component)StartOfRound.Instance.localPlayerController).gameObject.AddComponent<invisiblePlayerController>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!((Object)(object)val == (Object)(object)StartOfRound.Instance.localPlayerController) && (val.isPlayerControlled || val.isPlayerDead))
				{
					invisiblePlayerController2.HiddenPlayers.Add(val);
				}
			}
		}
	}
	public class invisiblePlayerController : MonoBehaviour
	{
		public List<PlayerControllerB> HiddenPlayers = new List<PlayerControllerB>();

		public void FixedUpdate()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded)
			{
				fixStuff();
				return;
			}
			foreach (PlayerControllerB hiddenPlayer in HiddenPlayers)
			{
				if (!((Object)(object)hiddenPlayer == (Object)(object)StartOfRound.Instance.localPlayerController))
				{
					((Component)hiddenPlayer.thisPlayerModelLOD1).gameObject.SetActive(false);
					((Component)hiddenPlayer.thisPlayerModelLOD2).gameObject.SetActive(false);
					((Component)hiddenPlayer.thisPlayerModel).gameObject.SetActive(false);
					((Component)hiddenPlayer.playerBadgeMesh).gameObject.SetActive(false);
					((Component)hiddenPlayer.playerBetaBadgeMesh).gameObject.SetActive(false);
				}
			}
		}

		public void fixStuff()
		{
			foreach (PlayerControllerB hiddenPlayer in HiddenPlayers)
			{
				((Component)hiddenPlayer.thisPlayerModelLOD1).gameObject.SetActive(true);
				((Component)hiddenPlayer.thisPlayerModelLOD2).gameObject.SetActive(true);
				((Component)hiddenPlayer.thisPlayerModel).gameObject.SetActive(true);
				((Component)hiddenPlayer.playerBadgeMesh).gameObject.SetActive(true);
				((Component)hiddenPlayer.playerBetaBadgeMesh).gameObject.SetActive(true);
				if (MysteryDice.MoreCompanyPresent)
				{
					WhereDidMyFriendsGoPt2.ToggleCosmetics(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, hiddenPlayer), value: true);
				}
			}
			Object.Destroy((Object)(object)this);
		}
	}
	public class WhereDidMyFriendsGoPt2
	{
		public static void ToggleCosmetics(int playerID, bool value)
		{
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerID);
			CosmeticApplication componentInChildren = ((Component)playerByUserID).gameObject.GetComponentInChildren<CosmeticApplication>();
			if (!Object.op_Implicit((Object)(object)componentInChildren))
			{
				return;
			}
			componentInChildren.UpdateAllCosmeticVisibilities(false);
			foreach (CosmeticInstance spawnedCosmetic in componentInChildren.spawnedCosmetics)
			{
				((Component)spawnedCosmetic).gameObject.SetActive(value);
			}
		}
	}
	internal class Wormageddon : IEffect
	{
		public string Name => "Wormageddon";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Be ware of worms";

		public void Use()
		{
			Networker.Instance.SpawnWormssServerRPC();
		}

		public static void SpawnWorms()
		{
			for (int i = 0; i < Random.Range(3, 8); i++)
			{
				Misc.SpawnOutsideEnemy(GetEnemies.Sandworm);
			}
		}
	}
	internal class ZombieApocalypse : IEffect
	{
		public string Name => "Zombie apocalypse";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Zombie apocalypse!";

		public void Use()
		{
			int amount = Random.Range(8, 10);
			if (GetEnemies.Masked != null)
			{
				Misc.SpawnEnemyForced(GetEnemies.Masked, amount, isInside: true);
			}
		}
	}
	internal class ZombieToShip : IEffect
	{
		public class ZombieSuitData : MonoBehaviour
		{
			public int ZombieSuitID = 9999;
		}

		public string Name => "Zombie return swap";

		public EffectType Outcome => EffectType.Awful;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Returns you to the ship and places a zombie in your original position";

		public void Use()
		{
			Networker.Instance.ZombieToShipServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}

		public static void ZombieUseServer(int clientID)
		{
			//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_002f: 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_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_008f: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(clientID);
			Vector3 position = ((Component)playerByUserID).transform.position;
			Networker.Instance.TeleportToShipClientRPC(clientID);
			GameObject val = Object.Instantiate<GameObject>(GetEnemies.Masked.enemyType.enemyPrefab, position, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
			val.AddComponent<ZombieSuitData>().ZombieSuitID = playerByUserID.currentSuitID;
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			NetworkObjectReference netObj = NetworkObjectReference.op_Implicit(val.GetComponentInChildren<NetworkObject>());
			ZombieSetSuit(netObj, playerByUserID.currentSuitID);
		}

		public static void ZombieSetSuit(NetworkObjectReference netObj, int suitID)
		{
			NetworkObject val = default(NetworkObject);
			if (((NetworkObjectReference)(ref netObj)).TryGet(ref val, (NetworkManager)null))
			{
				MaskedPlayerEnemy component = ((Component)val).GetComponent<MaskedPlayerEnemy>();
				component.SetSuit(suitID);
				if (Object.op_Implicit((Object)(object)((EnemyAI)component).creatureAnimator))
				{
					((EnemyAI)component).creatureAnimator.StopPlayback();
				}
			}
		}

		public static void ZombieSyncData(NetworkObjectReference netObj)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			NetworkObject val = default(NetworkObject);
			ZombieSuitData zombieSuitData = default(ZombieSuitData);
			if (((NetworkObjectReference)(ref netObj)).TryGet(ref val, (NetworkManager)null) && ((Component)val).TryGetComponent<ZombieSuitData>(ref zombieSuitData))
			{
				Networker.Instance.SyncSuitIDClientRPC(netObj, zombieSuitData.ZombieSuitID);
			}
		}
	}
	internal class Zortin : IEffect
	{
		public string Name => "Zortin";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Zort";

		public void Use()
		{
			//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)
			//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_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_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)
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, "Violin");
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, "Accordion");
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, "Guitar");
			Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, GameNetworkManager.Instance.localPlayerController), 1, "Recorder");
		}
	}
	internal class ZortinTwo : IEffect
	{
		public string Name => "Zortin 2";

		public EffectType Outcome => EffectType.Great;

		public bool ShowDefaultTooltip => true;

		public string Tooltip => "Zort 2";

		public void Use()
		{
			Networker.Instance.doZortServerRpc(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, StartOfRound.Instance.localPlayerController));
		}

		public static void spawnZort(int playerid)
		{
			//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_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_00fc: 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_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_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_01f5: 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_0228: 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_0256: 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_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: 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_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: 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)
			RoundManager instance = RoundManager.Instance;
			PlayerControllerB playerByUserID = Misc.GetPlayerByUserID(playerid);
			List<NetworkObjectReference> list = new List<NetworkObjectReference>();
			List<int> list2 = new List<int>();
			List<float> list3 = new List<float>();
			Item itemByName = Misc.GetItemByName("Violin", matchCase: false);
			GameObject val = Object.Instantiate<GameObject>(itemByName.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
			GrabbableObject component = val.GetComponent<GrabbableObject>();
			((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
			component.fallTime = 0f;
			component.scrapValue = (int)((float)Random.Range(itemByName.minValue, itemByName.maxValue) * instance.scrapValueMultiplier);
			list2.Add(component.scrapValue);
			list3.Add(component.itemProperties.weight);
			NetworkObject component2 = val.GetComponent<NetworkObject>();
			component2.Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(component);
			val.GetComponent<GrabbableObject>().EnablePhysics(true);
			component.FallToGround(false, true, ((Component)playerByUserID).transform.position);
			list.Add(NetworkObjectReference.op_Implicit(component2));
			Item itemByName2 = Misc.GetItemByName("Accordion", matchCase: false);
			GameObject val2 = Object.Instantiate<GameObject>(itemByName2.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
			GrabbableObject component3 = val2.GetComponent<GrabbableObject>();
			((Component)component3).transform.rotation = Quaternion.Euler(component3.itemProperties.restingRotation);
			component3.fallTime = 0f;
			component3.scrapValue = (int)((float)Random.Range(itemByName2.minValue, itemByName2.maxValue) * instance.scrapValueMultiplier);
			list2.Add(component3.scrapValue);
			list3.Add(component3.itemProperties.weight);
			NetworkObject component4 = val2.GetComponent<NetworkObject>();
			component4.Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(val2.GetComponent<GrabbableObject>());
			val2.GetComponent<GrabbableObject>().EnablePhysics(true);
			component3.FallToGround(false, true, ((Component)playerByUserID).transform.position);
			list.Add(NetworkObjectReference.op_Implicit(component4));
			Item itemByName3 = Misc.GetItemByName("Guitar", matchCase: false);
			GameObject val3 = Object.Instantiate<GameObject>(itemByName3.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
			GrabbableObject component5 = val3.GetComponent<GrabbableObject>();
			((Component)component5).transform.rotation = Quaternion.Euler(component5.itemProperties.restingRotation);
			component5.fallTime = 0f;
			component5.scrapValue = (int)((float)Random.Range(itemByName3.minValue, itemByName3.maxValue) * instance.scrapValueMultiplier);
			list2.Add(component5.scrapValue);
			list3.Add(component5.itemProperties.weight);
			NetworkObject component6 = val3.GetComponent<NetworkObject>();
			component6.Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(val3.GetComponent<GrabbableObject>());
			val3.GetComponent<GrabbableObject>().EnablePhysics(true);
			component5.FallToGround(false, true, ((Component)playerByUserID).transform.position);
			list.Add(NetworkObjectReference.op_Implicit(component6));
			Item itemByName4 = Misc.GetItemByName("Recorder", matchCase: false);
			GameObject val4 = Object.Instantiate<GameObject>(itemByName4.spawnPrefab, ((Component)playerByUserID).transform.position, Quaternion.identity, instance.spawnedScrapContainer);
			GrabbableObject component7 = val4.GetComponent<GrabbableObject>();
			((Component)component7).transform.rotation = Quaternion.Euler(component7.itemProperties.restingRotation);
			component7.fallTime = 0f;
			component7.scrapValue = (int)((float)Random.Range(itemByName4.minValue, itemByName4.maxValue) * instance.scrapValueMultiplier);
			list2.Add(component7.scrapValue);
			list3.Add(component7.itemProperties.weight);
			NetworkObject component8 = val4.GetComponent<NetworkObject>();
			component8.Spawn(false);
			CullFactorySoftCompat.RefreshGrabbableObjectPosition(val4.GetComponent<GrabbableObject>());
			val4.GetComponent<GrabbableObject>().EnablePhysics(true);
			component7.FallToGround(false, true, ((Component)playerByUserID).transform.position);
			list.Add(NetworkObjectReference.op_Implicit(component8));
			((MonoBehaviour)instance).StartCoroutine(DelaySync(instance, list.ToArray(), list2.ToArray(), list3.ToArray()));
			Networker.Instance.doZortStuffServerRpc(component2.NetworkObjectId, component8.NetworkObjectId, component4.NetworkObjectId, component6.NetworkObjectId);
		}

		private static IEnumerator DelaySync(RoundManager RM, NetworkObjectReference[] netObjs, int[] scrapValues, float[] scrapWeights)
		{
			yield return (object)new WaitForSeconds(2f);
			RM.SyncScrapValuesClientRpc(netObjs, scrapValues);
			Networker.Instance.SyncItemWeightsClientRPC(netObjs, scrapWeights);
		}
	}
}
namespace MysteryDice.Dice
{
	public class ChronosDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[2]
			{
				EffectType.Awful,
				EffectType.Bad
			});
			RollToEffect.Add(3, new EffectType[2]
			{
				EffectType.Mixed,
				EffectType.Bad
			});
			RollToEffect.Add(4, new EffectType[3]
			{
				EffectType.Bad,
				EffectType.Good,
				EffectType.Great
			});
			RollToEffect.Add(5, new EffectType[2]
			{
				EffectType.Good,
				EffectType.Great
			});
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
		}

		public override void DestroyObject()
		{
			Object.Destroy((Object)(object)DiceModel.GetComponent<ColorGradient>());
			base.DestroyObject();
		}

		public override void Roll()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Roll Chronos");
			}
			try
			{
				float normalizedTimeOfDay = TimeOfDay.Instance.normalizedTimeOfDay;
				WeightedList<int> weightedList = new WeightedList<int>();
				if (!MysteryDice.chronosUpdatedTimeOfDay.Value)
				{
					weightedList.Add(1, 1 + (int)(normalizedTimeOfDay * 10f));
					weightedList.Add(2, 1 + (int)(normalizedTimeOfDay * 8f));
					weightedList.Add(3, 1 + (int)(normalizedTimeOfDay * 6f));
					weightedList.Add(4, 1 + (int)(normalizedTimeOfDay * 3f));
					weightedList.Add(5, 1 + (int)(normalizedTimeOfDay * 1f));
					weightedList.Add(6, 1);
				}
				else if (MysteryDice.chronosUpdatedTimeOfDay.Value)
				{
					if (normalizedTimeOfDay < 0.5f)
					{
						weightedList.Add(1, 1 + (int)(normalizedTimeOfDay * 2f));
						weightedList.Add(2, 1 + (int)(normalizedTimeOfDay * 4f));
						weightedList.Add(3, 1 + (int)(normalizedTimeOfDay * 6f));
						weightedList.Add(4, 1 + (int)((1f - normalizedTimeOfDay) * 6f));
						weightedList.Add(5, 1 + (int)((1f - normalizedTimeOfDay) * 8f));
						weightedList.Add(6, 1 + (int)((1f - normalizedTimeOfDay) * 10f));
					}
					else if (normalizedTimeOfDay >= 0.5f)
					{
						weightedList.Add(1, 1 + (int)(normalizedTimeOfDay * 10f));
						weightedList.Add(2, 1 + (int)(normalizedTimeOfDay * 8f));
						weightedList.Add(3, 1 + (int)(normalizedTimeOfDay * 6f));
						weightedList.Add(4, 1 + (int)((1f - normalizedTimeOfDay) * 6f));
						weightedList.Add(5, 1 + (int)((1f - normalizedTimeOfDay) * 4f));
						weightedList.Add(6, 1 + (int)((1f - normalizedTimeOfDay) * 2f));
					}
				}
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = weightedList.Next();
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						DieBehaviour.ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "ChronosDie";
		}
	}
	public class CodeRebirthDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[3]
			{
				EffectType.Awful,
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(2, new EffectType[3]
			{
				EffectType.Bad,
				EffectType.Awful,
				EffectType.Mixed
			});
			RollToEffect.Add(3, new EffectType[3]
			{
				EffectType.Mixed,
				EffectType.Bad,
				EffectType.Good
			});
			RollToEffect.Add(4, new EffectType[3]
			{
				EffectType.Good,
				EffectType.Mixed,
				EffectType.Bad
			});
			RollToEffect.Add(5, new EffectType[3]
			{
				EffectType.Good,
				EffectType.Great,
				EffectType.Mixed
			});
			RollToEffect.Add(6, new EffectType[3]
			{
				EffectType.Great,
				EffectType.Good,
				EffectType.Mixed
			});
		}

		public override void Roll()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Roll Code Rebirth");
			}
			try
			{
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = Random.Range(1, 7);
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, MysteryDice.CodeRebirthPresent ? CodeRebirthEffects : Effects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						DieBehaviour.ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "CodeRebirthDie";
		}
	}
	public abstract class DieBehaviour : PhysicsProp
	{
		public enum ShowEffect
		{
			ALL,
			NONE,
			DEFAULT,
			RANDOM
		}

		public enum DiceType
		{
			CHRONOS,
			EMERGENCY,
			GAMBLER,
			RUSTY,
			SACRIFICER,
			SAINT,
			SURFACED,
			CODEREBIRTH,
			STEVE
		}

		public static List<IEffect> AllEffects = new List<IEffect>();

		public static List<IEffect> CompleteEffects = new List<IEffect>();

		public static List<IEffect> AllowedEffects = new List<IEffect>();

		public static List<IEffect> AwfulEffects = new List<IEffect>();

		public static List<IEffect> GoodEffects = new List<IEffect>();

		public static List<IEffect> GreatEffects = new List<IEffect>();

		public static List<IEffect> MixedEffects = new List<IEffect>();

		public static List<IEffect> BadEffects = new List<IEffect>();

		public static List<ConfigEntry<bool>> effectConfigs = new List<ConfigEntry<bool>>();

		public GameObject DiceModel;

		public List<IEffect> Effects = new List<IEffect>();

		private static List<string> surfacedNames = new List<string>();

		private static List<string> CodeRebirthNames = new List<string>();

		public static List<string> SteveNames = new List<string>();

		public List<IEffect> SurfacedEffects = new List<IEffect>();

		public List<IEffect> CodeRebirthEffects = new List<IEffect>();

		public List<IEffect> SteveEffects = new List<IEffect>();

		public Dictionary<int, EffectType[]> RollToEffect = new Dictionary<int, EffectType[]>();

		public bool wasEnemy = false;

		public bool wasGhost = false;

		public bool wasCurse = false;

		public bool isRolling = false;

		public IEffect nextEffect;

		public PlayerControllerB PlayerUser = null;

		public EnemyAI EnemyUser = null;

		public DiceType myType;

		private bool isDestroyed = false;

		public virtual void SetupDiceEffects()
		{
			Effects = new List<IEffect>(AllowedEffects);
			SurfacedEffects = AllowedEffects.Where((IEffect e) => surfacedNames.Contains(e.Name)).ToList();
			CodeRebirthEffects = AllowedEffects.Where((IEffect e) => CodeRebirthNames.Contains(e.Name)).ToList();
			SteveEffects = AllowedEffects.Where((IEffect e) => SteveNames.Contains(e.Name)).ToList();
		}

		public virtual void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[1] { EffectType.Bad });
			RollToEffect.Add(3, new EffectType[1] { EffectType.Mixed });
			RollToEffect.Add(4, new EffectType[1] { EffectType.Mixed });
			RollToEffect.Add(5, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
		}

		public override void Start()
		{
			//IL_00aa: 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_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)
			//IL_00fb: 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_012b: 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)
			((GrabbableObject)this).Start();
			if (myType != DiceType.STEVE)
			{
				DiceModel = ((Component)((Component)this).gameObject.transform.Find("Model")).gameObject;
			}
			if (myType != DiceType.STEVE)
			{
				DiceModel.AddComponent<Spinner>();
			}
			SetupDiceEffects();
			SetupRollToEffectMapping();
			SetupDiceStuff();
			if (MysteryDice.aprilFoolsConfig.Value)
			{
				if (((NetworkBehaviour)this).IsHost)
				{
					((MonoBehaviour)this).StartCoroutine(waitResize());
				}
				((Component)this).gameObject.transform.position = new Vector3(((Component)this).gameObject.transform.position.x, ((Component)this).gameObject.transform.position.y + 1.5f, ((Component)this).gameObject.transform.position.z);
				((GrabbableObject)this).targetFloorPosition = new Vector3(((Component)this).gameObject.transform.position.x, ((Component)this).gameObject.transform.position.y + 1.5f, ((Component)this).gameObject.transform.position.z);
			}
		}

		public IEnumerator waitResize()
		{
			yield return (object)new WaitForSeconds(1f);
			Vector3 randomSize = new Vector3(Random.Range(0.4f, 1.7f), Random.Range(0.4f, 1.7f), Random.Range(0.4f, 1.7f));
			Networker.Instance.setDiceSizeClientRPC(((NetworkBehaviour)this).NetworkObject.NetworkObjectId, randomSize);
		}

		public void SetupDiceStuff()
		{
			switch (myType)
			{
			case DiceType.CHRONOS:
				DiceModel.AddComponent<ColorGradient>();
				break;
			case DiceType.EMERGENCY:
				DiceModel.AddComponent<Blinking>();
				((GrabbableObject)this).itemProperties.verticalOffset = 0f;
				break;
			case DiceType.GAMBLER:
				DiceModel.AddComponent<CycleSigns>();
				DiceModel.GetComponent<Spinner>().NewDice = true;
				break;
			case DiceType.RUSTY:
				DiceModel.GetComponent<Spinner>().NewDice = true;
				break;
			case DiceType.SACRIFICER:
				DiceModel.GetComponent<Spinner>().NewDice = true;
				break;
			case DiceType.SAINT:
				((Component)DiceModel.transform.Find("halo")).gameObject.AddComponent<HaloSpin>();
				break;
			case DiceType.SURFACED:
				DiceModel = ((Component)((Component)this).gameObject.transform.Find("Model")).gameObject;
				DiceModel.GetComponent<Spinner>().NewDice = true;
				break;
			case DiceType.CODEREBIRTH:
				DiceModel = ((Component)((Component)this).gameObject.transform.Find("Model")).gameObject;
				DiceModel.GetComponent<Spinner>().NewDice = true;
				break;
			case DiceType.STEVE:
				DiceModel = ((Component)((Component)this).gameObject.transform.Find("SteveLeLePoissonDé")).gameObject;
				break;
			}
		}

		public override void PocketItem()
		{
			if (Object.op_Implicit((Object)(object)DiceModel.GetComponent<Renderer>()))
			{
				DiceModel.GetComponent<Renderer>().enabled = true;
			}
			DiceModel.SetActive(false);
			PlayerUser = ((GrabbableObject)this).playerHeldBy;
			((GrabbableObject)this).PocketItem();
		}

		public override void EquipItem()
		{
			PlayerUser = ((GrabbableObject)this).playerHeldBy;
			DiceModel.SetActive(true);
			if ((Object)(object)DiceModel.GetComponent<Renderer>() != (Object)null)
			{
				DiceModel.GetComponent<Renderer>().enabled = true;
			}
			((PhysicsProp)this).EquipItem();
		}

		public override void OnHitGround()
		{
			((GrabbableObject)this).OnHitGround();
			DiceModel.SetActive(true);
			if (!((Object)(object)PlayerUser == (Object)null) && MysteryDice.toggleCursed.Value && Networker.Instance.cursedPeople.Contains(PlayerUser.playerSteamId) && Random.value < 0.6f)
			{
				((MonoBehaviour)this).StartCoroutine(doStuff(8844199, PlayerUser));
			}
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			//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)
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			if (buttonDown && !((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded && !((Object)(object)((GrabbableObject)this).playerHeldBy == (Object)null))
			{
				PlayerUser = ((GrabbableObject)this).playerHeldBy;
				int userID = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, ((GrabbableObject)this).playerHeldBy);
				GameNetworkManager.Instance.localPlayerController.DiscardHeldObject(true, (NetworkObject)null, ((GrabbableObject)this).GetItemFloorPosition(DiceModel.transform.parent.position), false);
				SyncDropServerRPC(userID, Random.Range(0, 10));
			}
		}

		public IEnumerator doStuff(int dropperID, PlayerControllerB player)
		{
			if (!((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.shipHasLanded && !((Object)(object)StartOfRound.Instance.localPlayerController != (Object)(object)player) && ((NetworkBehaviour)this).IsHost)
			{
				SyncDropServerRPC(dropperID, Random.Range(0, 10));
			}
			yield break;
		}

		public virtual IEnumerator UseTimer(int userID, int spinTime)
		{
			if (isDestroyed || (Object)(object)this == (Object)null || (Object)(object)((Component)this).gameObject == (Object)null)
			{
				yield break;
			}
			try
			{
				if (!MysteryDice.randomSpinTime.Value)
				{
					spinTime = 3;
				}
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Starting Use Timer with Time: " + spinTime));
				}
				if (myType != DiceType.STEVE)
				{
					DiceModel.GetComponent<Spinner>().StartHyperSpinning(spinTime);
				}
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)"After Hyperspin");
				}
			}
			catch (Exception ex)
			{
				Exception e = ex;
				MysteryDice.CustomLogger.LogError((object)e);
			}
			for (float t = 0f; t < (float)spinTime; t += Time.deltaTime)
			{
				yield return null;
			}
			try
			{
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)"BeforeExplosion");
				}
				if (MysteryDice.doDiceExplosion.Value && (Object)(object)this != (Object)null && (Object)(object)((Component)this).gameObject != (Object)null)
				{
					Landmine.SpawnExplosion(((Component)this).gameObject.transform.position, true, 0f, 0f, 0, 0f, (GameObject)null, false);
				}
				switch (userID)
				{
				case 6409046:
					wasEnemy = true;
					if (MysteryDice.aprilFoolsConfig.Value)
					{
						AprilFoolsRoll();
					}
					else
					{
						Roll();
					}
					goto IL_0421;
				case 7510501:
					wasGhost = true;
					if (MysteryDice.aprilFoolsConfig.Value)
					{
						AprilFoolsRoll();
					}
					else
					{
						Roll();
					}
					goto IL_0421;
				case 8844199:
					wasCurse = true;
					if (MysteryDice.aprilFoolsConfig.Value)
					{
						AprilFoolsRoll();
					}
					else
					{
						Roll();
					}
					goto IL_0421;
				default:
					{
						if (Misc.isPlayerLocal(userID))
						{
							if (StartOfRound.Instance == null || StartOfRound.Instance.inShipPhase || !StartOfRound.Instance.shipHasLanded)
							{
								yield break;
							}
							if (StartOfRound.Instance.currentLevel.PlanetName == "71 Gordion" || StartOfRound.Instance.currentLevel.PlanetName == "98 Galetry")
							{
								Misc.SafeTipMessage("Company penalty", "Do not try this again.");
								IEffect effect = getRandomEffectByType(EffectType.Penalty, AllEffects);
								effect.Use();
							}
							if (StartOfRound.Instance.currentLevel.sceneName == "Oxyde")
							{
								IEffect effect2 = getRandomEffectByType(EffectType.SpecialPenalty, AllEffects);
								effect2.Use();
							}
							if (MysteryDice.aprilFoolsConfig.Value)
							{
								AprilFoolsRoll();
							}
							else
							{
								Roll();
							}
						}
						goto IL_0421;
					}
					IL_0421:
					DestroyObject();
					break;
				}
			}
			catch (Exception ex)
			{
				Exception e2 = ex;
				MysteryDice.CustomLogger.LogError((object)e2);
				DestroyObject();
			}
			yield return (object)new WaitForSeconds(0.4f);
		}

		[ServerRpc(RequireOwnership = false)]
		public virtual void SyncDropServerRPC(int userID, int Timer)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3757258078u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, userID);
				BytePacker.WriteValueBitPacked(val, Timer);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3757258078u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				isRolling = true;
				if (!((NetworkBehaviour)this).IsHost)
				{
					DropAndBlock(userID, Timer);
				}
				SyncDropClientRPC(userID, Timer);
			}
		}

		[ClientRpc]
		public virtual void SyncDropClientRPC(int userID, int Timer)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1737949898u, val2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, userID);
					BytePacker.WriteValueBitPacked(val, Timer);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1737949898u, val2, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					isRolling = true;
					DropAndBlock(userID, Timer);
				}
			}
		}

		public virtual void DropAndBlock(int userID, int Timer)
		{
			if (userID == 6409046)
			{
				wasEnemy = true;
			}
			if (userID == 7510501)
			{
				wasGhost = true;
			}
			if (userID == 8844199)
			{
				wasCurse = true;
			}
			((GrabbableObject)this).grabbable = false;
			((GrabbableObject)this).grabbableToEnemies = false;
			DiceModel.SetActive(true);
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(UseTimer(userID, Timer));
		}

		public virtual void DestroyObject()
		{
			if (isDestroyed)
			{
				return;
			}
			isDestroyed = true;
			((GrabbableObject)this).grabbable = false;
			((GrabbableObject)this).grabbableToEnemies = false;
			((GrabbableObject)this).deactivated = true;
			if (((NetworkBehaviour)this).IsHost)
			{
				string text = (((Object)(object)((Component)this).gameObject.transform.parent != (Object)null) ? ((Object)((Component)((Component)this).gameObject.transform.parent).gameObject).name : "orphan :(");
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Despawning object: " + ((Object)((Component)((NetworkBehaviour)this).NetworkObject).gameObject).name + "\nParent Object: " + text));
				}
				if (((Object)((Component)((NetworkBehaviour)this).NetworkObject).gameObject).name.StartsWith("Networker"))
				{
					MysteryDice.CustomLogger.LogDebug((object)"Well there's your issue >:D");
				}
				else
				{
					((MonoBehaviour)this).StartCoroutine(waitToDespawn());
				}
			}
		}

		public IEnumerator waitToDespawn()
		{
			yield return (object)new WaitForSeconds(1f);
			((NetworkBehaviour)this).NetworkObject.Despawn(true);
		}

		public virtual void Roll()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Starting Roll");
			}
			int num = Random.Range(1, 7);
			IEffect randomEffect = GetRandomEffect(num, Effects);
			if (randomEffect != null)
			{
				PlaySoundBasedOnEffect(randomEffect.Outcome);
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
				}
				randomEffect.Use();
				string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
				Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				ShowDefaultTooltip(randomEffect, num);
			}
		}

		public static IEffect getRandomEffectByType(EffectType type, List<IEffect> effectsToUse)
		{
			List<IEffect> list = new List<IEffect>();
			foreach (IEffect item in effectsToUse)
			{
				if (item.Outcome == type)
				{
					list.Add(item);
				}
			}
			return list[Random.Range(0, list.Count)];
		}

		public IEffect GetRandomEffect(int diceRoll, List<IEffect> effects)
		{
			if (nextEffect != null)
			{
				return nextEffect;
			}
			List<IEffect> list = new List<IEffect>();
			if (effects.Count == 0)
			{
				effects = new List<IEffect>(Effects);
			}
			foreach (IEffect effect in effects)
			{
				if (RollToEffect[diceRoll].Contains(effect.Outcome))
				{
					list.Add(effect);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			int index = Random.Range(0, list.Count);
			return list[index];
		}

		public void PlaySoundBasedOnEffect(EffectType effectType)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			AudioClip value;
			switch (effectType)
			{
			case EffectType.Awful:
				MysteryDice.sounds.TryGetValue("Bell2", out value);
				break;
			case EffectType.Bad:
				MysteryDice.sounds.TryGetValue("Bad1", out value);
				break;
			default:
				MysteryDice.sounds.TryGetValue("Good2", out value);
				break;
			}
			AudioSource.PlayClipAtPoint(value, ((Component)GameNetworkManager.Instance.localPlayerController).transform.position);
		}

		public static void ShowDefaultTooltip(IEffect effect, int diceRoll)
		{
			string text = "wat?";
			EffectType outcome = effect.Outcome;
			bool flag = false;
			string text2 = "wat?";
			string[] array = new string[3] { ":)", ">:)", "Have fun!" };
			string[] array2 = new string[3] { "Welp", "This will be fun...", "Uh oh" };
			string[] array3 = new string[4] { "Debatable", "I honestly don't know if this is good or bad", "ehhh", "at least it's not bad" };
			string[] array4 = new string[5] { "Enjoy.", "I like it", "Pretty good", "Yay!", "Woo!" };
			string[] array5 = new string[6] { ";)", "I love it!", "Lucky!", "YAY!!!", "Only the best!", "♥♥♥" };
			switch (outcome)
			{
			case EffectType.Awful:
				text = array[Random.Range(0, array.Length)];
				break;
			case EffectType.Bad:
				text = array2[Random.Range(0, array2.Length)];
				break;
			case EffectType.Good:
				text = array4[Random.Range(0, array4.Length)];
				break;
			case EffectType.Great:
				text = array5[Random.Range(0, array5.Length)];
				break;
			case EffectType.Mixed:
				text = array3[Random.Range(0, array3.Length)];
				break;
			}
			ShowEffect result = ShowEffect.NONE;
			Enum.TryParse<ShowEffect>(MysteryDice.DisplayResults.Value, out result);
			switch (result)
			{
			case ShowEffect.ALL:
				flag = true;
				text2 = effect.Tooltip;
				break;
			case ShowEffect.NONE:
				text2 = text;
				break;
			case ShowEffect.RANDOM:
			{
				int num = Random.Range(0, 101);
				text2 = ((num > 45) ? text : effect.Tooltip);
				break;
			}
			case ShowEffect.DEFAULT:
				text2 = ((!effect.ShowDefaultTooltip) ? effect.Tooltip : text);
				break;
			default:
				MysteryDice.CustomLogger.LogWarning((object)("An error occured with DisplayResults The value is: " + MysteryDice.DisplayResults.Value));
				text2 = ((!effect.ShowDefaultTooltip) ? effect.Tooltip : text);
				break;
			}
			Misc.SafeTipMessage($"Rolled {diceRoll}", text2);
		}

		public static void Config()
		{
			MysteryDice.MainRegisterNewEffect(new NeckBreak());
			SteveNames.Add(new SelectEffect().Name);
			MysteryDice.MainRegisterNewEffect(new SelectEffect());
			SteveNames.Add(new Fly().Name);
			MysteryDice.MainRegisterNewEffect(new Fly());
			MysteryDice.MainRegisterNewEffect(new LeverShake());
			MysteryDice.MainRegisterNewEffect(new HyperShake());
			MysteryDice.MainRegisterNewEffect(new MovingLandmines());
			MysteryDice.MainRegisterNewEffect(new OutsideCoilhead());
			SteveNames.Add(new Arachnophobia().Name);
			MysteryDice.MainRegisterNewEffect(new Arachnophobia());
			MysteryDice.MainRegisterNewEffect(new BrightFlashlight());
			SteveNames.Add(new IncreasedRate().Name);
			MysteryDice.MainRegisterNewEffect(new IncreasedRate());
			MysteryDice.MainRegisterNewEffect(new DoorMalfunction());
			MysteryDice.MainRegisterNewEffect(new Purge());
			MysteryDice.MainRegisterNewEffect(new InfiniteStaminaAll());
			SteveNames.Add(new InfiniteStamina().Name);
			MysteryDice.MainRegisterNewEffect(new InfiniteStamina());
			MysteryDice.MainRegisterNewEffect(new Pathfinder());
			MysteryDice.MainRegisterNewEffect(new Shotgun());
			MysteryDice.MainRegisterNewEffect(new ShipTurret());
			MysteryDice.MainRegisterNewEffect(new TurretHell());
			MysteryDice.MainRegisterNewEffect(new SilentMine());
			MysteryDice.MainRegisterNewEffect(new ZombieToShip());
			MysteryDice.MainRegisterNewEffect(new InvertDoorLock());
			SteveNames.Add(new AlarmCurse().Name);
			MysteryDice.MainRegisterNewEffect(new AlarmCurse());
			SteveNames.Add(new JumpscareGlitch().Name);
			MysteryDice.MainRegisterNewEffect(new JumpscareGlitch());
			MysteryDice.MainRegisterNewEffect(new Armageddon());
			MysteryDice.MainRegisterNewEffect(new Beepocalypse());
			MysteryDice.MainRegisterNewEffect(new RebeliousCoilHeads());
			MysteryDice.MainRegisterNewEffect(new TurnOffLights());
			SteveNames.Add(new HealAndRestore().Name);
			MysteryDice.MainRegisterNewEffect(new HealAndRestore());
			MysteryDice.MainRegisterNewEffect(new ScrapJackpot());
			MysteryDice.MainRegisterNewEffect(new Swap());
			MysteryDice.MainRegisterNewEffect(new ModifyPitch());
			MysteryDice.MainRegisterNewEffect(new MineOverflow());
			MysteryDice.MainRegisterNewEffect(new MineOverflowOutside());
			SteveNames.Add(new InstaJester().Name);
			MysteryDice.MainRegisterNewEffect(new InstaJester());
			MysteryDice.MainRegisterNewEffect(new FakeFireExits());
			MysteryDice.MainRegisterNewEffect(new FireExitBlock());
			MysteryDice.MainRegisterNewEffect(new ReturnToShip());
			SteveNames.Add(new ReturnToShipTogether().Name);
			MysteryDice.MainRegisterNewEffect(new ReturnToShipTogether());
			SteveNames.Add(new TeleportInside().Name);
			MysteryDice.MainRegisterNewEffect(new TeleportInside());
			MysteryDice.MainRegisterNewEffect(new BugPlague());
			MysteryDice.MainRegisterNewEffect(new ZombieApocalypse());
			MysteryDice.MainRegisterNewEffect(new Revive());
			MysteryDice.MainRegisterNewEffect(new Detonate());
			MysteryDice.MainRegisterNewEffect(new RandomStoreItem());
			MysteryDice.MainRegisterNewEffect(new RandomGreatStoreItem());
			MysteryDice.MainRegisterNewEffect(new BatteryDrain());
			SteveNames.Add(new EveryoneToSomeone().Name);
			MysteryDice.MainRegisterNewEffect(new EveryoneToSomeone());
			MysteryDice.MainRegisterNewEffect(new LightBurden());
			MysteryDice.MainRegisterNewEffect(new ItemDuplicator());
			MysteryDice.MainRegisterNewEffect(new HeavyBurden());
			MysteryDice.MainRegisterNewEffect(new DrunkForAll(), defaultOff: false, superDebug: true);
			MysteryDice.MainRegisterNewEffect(new Drunk());
			MysteryDice.MainRegisterNewEffect(new GoldenTouch());
			MysteryDice.MainRegisterNewEffect(new Reroll());
			MysteryDice.MainRegisterNewEffect(new NeckSpin());
			SteveNames.Add(new GiveAllDice().Name);
			MysteryDice.MainRegisterNewEffect(new GiveAllDice());
			MysteryDice.MainRegisterNewEffect(new InsideGiant());
			MysteryDice.MainRegisterNewEffect(new OutsideBugs());
			MysteryDice.MainRegisterNewEffect(new Maneaters());
			MysteryDice.MainRegisterNewEffect(new Delay());
			MysteryDice.MainRegisterNewEffect(new SpikeOverflowOutside(), defaultOff: true);
			MysteryDice.MainRegisterNewEffect(new Lasso());
			MysteryDice.MainRegisterNewEffect(new Meteors());
			MysteryDice.MainRegisterNewEffect(new Barbers());
			MysteryDice.MainRegisterNewEffect(new InvisibleEnemy());
			SteveNames.Add(new EmergencyMeeting().Name);
			MysteryDice.MainRegisterNewEffect(new EmergencyMeeting());
			MysteryDice.MainRegisterNewEffect(new Ghosts());
			MysteryDice.MainRegisterNewEffect(new MerryChristmas());
			SteveNames.Add(new NutcrackerOutside().Name);
			MysteryDice.MainRegisterNewEffect(new NutcrackerOutside());
			MysteryDice.MainRegisterNewEffect(new AllSameScrap());
			MysteryDice.MainRegisterNewEffect(new Eggs());
			MysteryDice.MainRegisterNewEffect(new EggFountain());
			MysteryDice.MainRegisterNewEffect(new FlashFountain());
			MysteryDice.MainRegisterNewEffect(new InsideDog());
			SteveNames.Add(new EggBoots().Name);
			MysteryDice.MainRegisterNewEffect(new EggBoots());
			MysteryDice.MainRegisterNewEffect(new EggBootsForAll(), defaultOff: false, superDebug: true);
			MysteryDice.MainRegisterNewEffect(new RerollALL(), defaultOff: false, superDebug: true);
			MysteryDice.MainRegisterNewEffect(new TulipTrapeze());
			SteveNames.Add(new BlameGlitch().Name);
			MysteryDice.MainRegisterNewEffect(new BlameGlitch(), defaultOff: true);
			MysteryDice.MainRegisterNewEffect(new HappyDay());
			MysteryDice.MainRegisterNewEffect(new SpicyNuggies());
			SteveNames.Add(new Martyrdom().Name);
			MysteryDice.MainRegisterNewEffect(new Martyrdom());
			SteveNames.Add(new Lovers().Name);
			MysteryDice.MainRegisterNewEffect(new Lovers());
			MysteryDice.MainRegisterNewEffect(new BIGSpike(), defaultOff: true);
			MysteryDice.MainRegisterNewEffect(new SpeedUp(), defaultOff: true, superDebug: true);
			MysteryDice.MainRegisterNewEffect(new GiveCredits());
			MysteryDice.MainRegisterNewEffect(new RemoveCredits());
			MysteryDice.MainRegisterNewEffect(new BigDelivery());
			MysteryDice.MainRegisterNewEffect(new DorjesDream());
			SteveNames.Add(new MoreLives().Name);
			MysteryDice.MainRegisterNewEffect(new MoreLives());
			MysteryDice.MainRegisterNewEffect(new LizzieDog());
			MysteryDice.MainRegisterNewEffect(new WhereDidMyFriendsGo());
			SteveNames.Add(new Confusion().Name);
			MysteryDice.MainRegisterNewEffect(new Confusion());
			MysteryDice.MainRegisterNewEffect(new StupidConfusion(), defaultOff: true);
			SteveNames.Add(new NutsBaby().Name);
			MysteryDice.MainRegisterNewEffect(new NutsBaby());
			MysteryDice.MainRegisterNewEffect(new Papercut(), defaultOff: true);
			SteveNames.Add(new BadLovers().Name);
			MysteryDice.MainRegisterNewEffect(new BadLovers());
			MysteryDice.MainRegisterNewEffect(new OopsAllBlank());
			MysteryDice.MainRegisterNewEffect(new AllAtOnce(), defaultOff: true, superDebug: true);
			MysteryDice.MainRegisterNewEffect(new Unkillable());
			MysteryDice.MainRegisterNewEffect(new FreebirdEnemy(), defaultOff: true);
			MysteryDice.MainRegisterNewEffect(new DoubleTrouble());
			SteveNames.Add(new ThreesCompany().Name);
			MysteryDice.MainRegisterNewEffect(new ThreesCompany());
			MysteryDice.MainRegisterNewEffect(new FreebirdTrap(), defaultOff: true);
			MysteryDice.MainRegisterNewEffect(new EvilFreebirdEnemy());
			MysteryDice.MainRegisterNewEffect(new MicroTrap(), defaultOff: true);
			SteveNames.Add(new ManyAds().Name);
			MysteryDice.MainRegisterNewEffect(new ManyAds());
			SteveNames.Add(new TulipBombers().Name);
			MysteryDice.MainRegisterNewEffect(new TulipBombers());
			SteveNames.Add(new MadScience().Name);
			MysteryDice.MainRegisterNewEffect(new MadScience());
			MysteryDice.MainRegisterNewEffect(new MadderScience());
			MysteryDice.MainRegisterNewEffect(new SpecialDetonate(), defaultOff: true);
			MysteryDice.MainRegisterNewEffect(new GalDetonate());
			MysteryDice.MainRegisterNewEffect(new AllFly());
			MysteryDice.MainRegisterNewEffect(new AddLife());
			MysteryDice.MainRegisterNewEffect(new Overweight());
			MysteryDice.MainRegisterNewEffect(new HouseAlwaysWins());
			MysteryDice.MainRegisterNewEffect(new Lizard());
			MysteryDice.MainRegisterNewEffect(new MineExploder());
			MysteryDice.MainRegisterNewEffect(new TurretExploder());
			MysteryDice.MainRegisterNewEffect(new GlitchPill());
			MysteryDice.MainRegisterNewEffect(new GlitchPillTwo());
			MysteryDice.MainRegisterNewEffect(new JobAppPill());
			MysteryDice.MainRegisterNewEffect(new ChangePlaces());
			MysteryDice.MainRegisterNewEffect(new ReviveNext());
			MysteryDice.MainRegisterNewEffect(new RevivePercent());
			MysteryDice.MainRegisterNewEffect(new Hehehe());
			MysteryDice.MainRegisterNewEffect(new GlitchPillThree());
			MysteryDice.MainRegisterNewEffect(new ChangeVoices(), defaultOff: true);
			MysteryDice.MainRegisterNewEffect(new SpawnCruiser());
			MysteryDice.MainRegisterNewEffect(new Glitch());
			if (MysteryDice.TooManyEmotesPresent)
			{
				MysteryDice.MainRegisterNewEffect(new PerformRandomEmote());
			}
			if (MysteryDice.lethalThingsPresent)
			{
				MysteryDice.MainRegisterNewEffect(new TPTraps());
				MysteryDice.MainRegisterNewEffect(new MovingTPTraps());
				MysteryDice.MainRegisterNewEffect(new TpOverflowOutside());
				MysteryDice.MainRegisterNewEffect(new SilentTP());
			}
			if (MysteryDice.LethalMonPresent)
			{
				MysteryDice.MainRegisterNewEffect(new CatchEmAll());
				MysteryDice.MainRegisterNewEffect(new LegendaryCatch());
			}
			if (MysteryDice.LCOfficePresent)
			{
				MysteryDice.MainRegisterNewEffect(new InsideShrimps());
			}
			if (MysteryDice.SurfacedPresent)
			{
				surfacedNames.Add(new Martyrdom().Name);
				surfacedNames.Add(new MantisShrimps().Name);
				MysteryDice.MainRegisterNewEffect(new MantisShrimps());
				surfacedNames.Add(new SeaminesOutside().Name);
				MysteryDice.MainRegisterNewEffect(new SeaminesOutside());
				surfacedNames.Add(new BerthaOutside().Name);
				MysteryDice.MainRegisterNewEffect(new BerthaOutside());
				surfacedNames.Add(new Bruce().Name);
				MysteryDice.MainRegisterNewEffect(new Bruce());
				surfacedNames.Add(new Nemo().Name);
				MysteryDice.MainRegisterNewEffect(new Nemo());
				surfacedNames.Add(new BellCrabs().Name);
				MysteryDice.MainRegisterNewEffect(new BellCrabs());
				surfacedNames.Add(new UrchinIndoors().Name);
				MysteryDice.MainRegisterNewEffect(new UrchinIndoors());
				surfacedNames.Add(new MineHardPlace().Name);
				SteveNames.Add(new MineHardPlace().Name);
				MysteryDice.MainRegisterNewEffect(new MineHardPlace());
				surfacedNames.Add(new Flinger().Name);
				MysteryDice.MainRegisterNewEffect(new Flinger());
				surfacedNames.Add(new BurgerFlippers().Name);
				MysteryDice.MainRegisterNewEffect(new BurgerFlippers());
				surfacedNames.Add(new ScaryMon().Name);
				MysteryDice.MainRegisterNewEffect(new ScaryMon());
				surfacedNames.Add(new BerthaLever().Name);
				MysteryDice.MainRegisterNewEffect(new BerthaLever());
				surfacedNames.Add(new InstantExplodingBerthas().Name);
				MysteryDice.MainRegisterNewEffect(new InstantExplodingBerthas());
				surfacedNames.Add(new BigJumpscare().Name);
				MysteryDice.MainRegisterNewEffect(new BigJumpscare());
				surfacedNames.Add(new BIGBertha().Name);
				SteveNames.Add(new BIGBertha().Name);
				MysteryDice.MainRegisterNewEffect(new BIGBertha());
				surfacedNames.Add(new MovingSeaTraps().Name);
				MysteryDice.MainRegisterNewEffect(new MovingSeaTraps());
				surfacedNames.Add(new BigFling().Name);
				MysteryDice.MainRegisterNewEffect(new BigFling());
				surfacedNames.Add(new SuperFlinger().Name);
				MysteryDice.MainRegisterNewEffect(new SuperFlinger());
				surfacedNames.Add(new Horseshootnt().Name);
				SteveNames.Add(new Horseshootnt().Name);
				MysteryDice.MainRegisterNewEffect(new Horseshootnt());
				surfacedNames.Add(new Bruiser().Name);
				MysteryDice.MainRegisterNewEffect(new Bruiser());
				surfacedNames.Add(new HorseshootSeat().Name);
				MysteryDice.MainRegisterNewEffect(new HorseshootSeat());
				surfacedNames.Add(new Rigo().Name);
				MysteryDice.MainRegisterNewEffect(new Rigo());
				surfacedNames.Add(new Nemosplosion().Name);
				MysteryDice.MainRegisterNewEffect(new Nemosplosion());
				surfacedNames.Add(new LongBertha().Name);
				SteveNames.Add(new LongBertha().Name);
				MysteryDice.MainRegisterNewEffect(new LongBertha());
				if (!MysteryDice.CodeRebirthPresent)
				{
				}
			}
			if (MysteryDice.LCTarotCardPresent)
			{
				MysteryDice.MainRegisterNewEffect(new TarotCards());
			}
			if (MysteryDice.TakeyPlushPresent)
			{
				SteveNames.Add(new TakeySmol().Name);
				MysteryDice.MainRegisterNewEffect(new TakeySmol());
			}
			if (MysteryDice.CodeRebirthPresent)
			{
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Tornado") != (Object)null)
				{
					CodeRebirthNames.Add(new Tornado().Name);
					MysteryDice.MainRegisterNewEffect(new Tornado());
				}
				if (CodeRebirthCheckConfigs.getTrap("Wooden Crate") != null)
				{
					CodeRebirthNames.Add(new CratesOutside().Name);
					MysteryDice.MainRegisterNewEffect(new CratesOutside());
					CodeRebirthNames.Add(new CratesInside().Name);
					MysteryDice.MainRegisterNewEffect(new CratesInside());
					CodeRebirthNames.Add(new MovingCrates().Name);
					SteveNames.Add(new MovingCrates().Name);
					MysteryDice.MainRegisterNewEffect(new MovingCrates());
					CodeRebirthNames.Add(new IFeelSafe().Name);
					SteveNames.Add(new IFeelSafe().Name);
					MysteryDice.MainRegisterNewEffect(new IFeelSafe());
				}
				if (CodeRebirthCheckConfigs.getTrap("FanTrapAnimated") != null)
				{
					CodeRebirthNames.Add(new Fans().Name);
					MysteryDice.MainRegisterNewEffect(new Fans());
					CodeRebirthNames.Add(new MovingFans().Name);
					MysteryDice.MainRegisterNewEffect(new MovingFans());
					CodeRebirthNames.Add(new FollowerFan().Name);
					MysteryDice.MainRegisterNewEffect(new FollowerFan());
					if (CodeRebirthCheckConfigs.getTrap("FlashTurretUpdated") != null)
					{
						SteveNames.Add(new Paparazzi().Name);
						CodeRebirthNames.Add(new Paparazzi().Name);
						MysteryDice.MainRegisterNewEffect(new Paparazzi());
					}
				}
				if (CodeRebirthCheckConfigs.getTrap("FlashTurretUpdated") != null)
				{
					CodeRebirthNames.Add(new Flashers().Name);
					MysteryDice.MainRegisterNewEffect(new Flashers());
					CodeRebirthNames.Add(new Bald().Name);
					SteveNames.Add(new Bald().Name);
					MysteryDice.MainRegisterNewEffect(new Bald());
				}
				if (CodeRebirthCheckConfigs.getTrap("FunctionalMicrowave") != null)
				{
					CodeRebirthNames.Add(new Microwave().Name);
					MysteryDice.MainRegisterNewEffect(new Microwave());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Transporter") != (Object)null)
				{
					CodeRebirthNames.Add(new FreebirdJimothy().Name);
					SteveNames.Add(new FreebirdJimothy().Name);
					MysteryDice.MainRegisterNewEffect(new FreebirdJimothy());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Janitor") != (Object)null && (Object)(object)CodeRebirthCheckConfigs.getEnemy("Transporter") != (Object)null)
				{
					SteveNames.Add(new CleaningCrew().Name);
					CodeRebirthNames.Add(new CleaningCrew().Name);
					MysteryDice.MainRegisterNewEffect(new CleaningCrew());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Redwood Titan") != (Object)null)
				{
					CodeRebirthNames.Add(new TheRumbling().Name);
					MysteryDice.MainRegisterNewEffect(new TheRumbling());
				}
				if (CodeRebirthCheckConfigs.getTrap("Crane") != null)
				{
					CodeRebirthNames.Add(new SmolCrane().Name);
					MysteryDice.MainRegisterNewEffect(new SmolCrane());
					CodeRebirthNames.Add(new BeegCrane().Name);
					MysteryDice.MainRegisterNewEffect(new BeegCrane());
					CodeRebirthNames.Add(new MovingCrane().Name);
					MysteryDice.MainRegisterNewEffect(new MovingCrane());
				}
				if (CodeRebirthCheckConfigs.getTrap("EmergingCactus1") != null)
				{
					CodeRebirthNames.Add(new TheDesert().Name);
					MysteryDice.MainRegisterNewEffect(new TheDesert());
				}
				MysteryDice.MainRegisterNewEffect(new OxydePenalty(), defaultOff: true);
				CodeRebirthNames.Add(new Zortin().Name);
				SteveNames.Add(new Zortin().Name);
				MysteryDice.MainRegisterNewEffect(new Zortin());
				CodeRebirthNames.Add(new ZortinTwo().Name);
				SteveNames.Add(new ZortinTwo().Name);
				MysteryDice.MainRegisterNewEffect(new ZortinTwo());
				CodeRebirthNames.Add(new BlameGlitch().Name);
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Nancy") != (Object)null)
				{
					CodeRebirthNames.Add(new Healers().Name);
					MysteryDice.MainRegisterNewEffect(new Healers());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Mistress") != (Object)null)
				{
					CodeRebirthNames.Add(new ManyMistress().Name);
					MysteryDice.MainRegisterNewEffect(new ManyMistress());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Guardsman") != (Object)null)
				{
					CodeRebirthNames.Add(new GuardsmanOutside().Name);
					MysteryDice.MainRegisterNewEffect(new GuardsmanOutside());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Peace Keeper") != (Object)null)
				{
					CodeRebirthNames.Add(new PeaceTreaty().Name);
					MysteryDice.MainRegisterNewEffect(new PeaceTreaty());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Mistress") != (Object)null && (Object)(object)CodeRebirthCheckConfigs.getEnemy("Rabbit Magician") != (Object)null && (Object)(object)CodeRebirthCheckConfigs.getEnemy("Lord Of The Manor") != (Object)null)
				{
					CodeRebirthNames.Add(new HappyFamily().Name);
					MysteryDice.MainRegisterNewEffect(new HappyFamily());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Real Enemy SnailCat") != (Object)null)
				{
					CodeRebirthNames.Add(new ImmortalSnailcat().Name);
					MysteryDice.MainRegisterNewEffect(new ImmortalSnailcat());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("Lord Of The Manor") != (Object)null)
				{
					CodeRebirthNames.Add(new EtTuBrute().Name);
					MysteryDice.MainRegisterNewEffect(new EtTuBrute());
				}
				if ((Object)(object)CodeRebirthCheckConfigs.getEnemy("CutieFly") != (Object)null)
				{
					CodeRebirthNames.Add(new HeatSeakingCutieFly().Name);
					MysteryDice.MainRegisterNewEffect(new HeatSeakingCutieFly());
				}
			}
			if (MysteryDice.DiversityPresent)
			{
				if (DiversityEffect1.checkConfigs())
				{
					MysteryDice.MainRegisterNewEffect(new DiversityEffect1());
				}
				if (DiversityEffect2.checkConfigs())
				{
					MysteryDice.MainRegisterNewEffect(new DiversityEffect2());
				}
			}
			if (MysteryDice.BombCollarPresent)
			{
				MysteryDice.MainRegisterNewEffect(new BombCollars());
				MysteryDice.MainRegisterNewEffect(new EveryoneFriends());
			}
			if (MysteryDice.NavMeshInCompanyPresent)
			{
				MysteryDice.MainRegisterNewEffect(new NavMeshPenalty(), defaultOff: true);
			}
			List<IEffect> allEffects = AllEffects.OrderBy((IEffect o) => o.Name).ToList();
			CompleteEffects.AddRange(AllEffects);
			CompleteEffects = CompleteEffects.OrderBy((IEffect o) => o.Name).ToList();
			AllEffects = allEffects;
		}

		public void setupChronosRoll()
		{
			RollToEffect.Clear();
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[2]
			{
				EffectType.Awful,
				EffectType.Bad
			});
			RollToEffect.Add(3, new EffectType[2]
			{
				EffectType.Mixed,
				EffectType.Bad
			});
			RollToEffect.Add(4, new EffectType[3]
			{
				EffectType.Bad,
				EffectType.Good,
				EffectType.Great
			});
			RollToEffect.Add(5, new EffectType[2]
			{
				EffectType.Good,
				EffectType.Great
			});
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
			doChronosRoll();
		}

		public void doChronosRoll()
		{
			try
			{
				float normalizedTimeOfDay = TimeOfDay.Instance.normalizedTimeOfDay;
				WeightedList<int> weightedList = new WeightedList<int>();
				if (!MysteryDice.chronosUpdatedTimeOfDay.Value)
				{
					weightedList.Add(1, 1 + (int)(normalizedTimeOfDay * 10f));
					weightedList.Add(2, 1 + (int)(normalizedTimeOfDay * 8f));
					weightedList.Add(3, 1 + (int)(normalizedTimeOfDay * 6f));
					weightedList.Add(4, 1 + (int)(normalizedTimeOfDay * 3f));
					weightedList.Add(5, 1 + (int)(normalizedTimeOfDay * 1f));
					weightedList.Add(6, 1);
				}
				else if (MysteryDice.chronosUpdatedTimeOfDay.Value)
				{
					if (normalizedTimeOfDay < 0.5f)
					{
						weightedList.Add(1, 1 + (int)((1f - normalizedTimeOfDay) * 10f));
						weightedList.Add(2, 1 + (int)((1f - normalizedTimeOfDay) * 8f));
						weightedList.Add(3, 1 + (int)((1f - normalizedTimeOfDay) * 6f));
						weightedList.Add(4, 1 + (int)(normalizedTimeOfDay * 4f));
						weightedList.Add(5, 1 + (int)(normalizedTimeOfDay * 2f));
						weightedList.Add(6, 1 + (int)normalizedTimeOfDay);
					}
					else if (normalizedTimeOfDay >= 0.5f)
					{
						weightedList.Add(1, 1 + (int)(normalizedTimeOfDay * 4f));
						weightedList.Add(2, 1 + (int)(normalizedTimeOfDay * 2f));
						weightedList.Add(3, 1 + (int)normalizedTimeOfDay);
						weightedList.Add(4, 1 + (int)((1f - normalizedTimeOfDay) * 6f));
						weightedList.Add(5, 1 + (int)((1f - normalizedTimeOfDay) * 8f));
						weightedList.Add(6, 1 + (int)((1f - normalizedTimeOfDay) * 10f));
					}
				}
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = weightedList.Next();
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		public void setupEmergencyRoll()
		{
			RollToEffect.Clear();
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[1] { EffectType.Bad });
			RollToEffect.Add(3, new EffectType[1] { EffectType.Mixed });
			RollToEffect.Add(4, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(5, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
			doEmergencyRoll();
		}

		public void doEmergencyRoll()
		{
			try
			{
				int num = Random.Range(1, 7);
				IEffect effect = GetRandomEffect(num, Effects);
				if (effect != null)
				{
					PlaySoundBasedOnEffect(effect.Outcome);
					if (num > 2)
					{
						effect = new ReturnToShip();
					}
					if (num == 6)
					{
						effect = new ReturnToShipTogether();
					}
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + effect.Name));
					}
					effect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, effect.Name, num);
					ShowDefaultTooltip(effect, num);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
				new ReturnToShip().Use();
			}
		}

		public void setupGamblerRoll()
		{
			RollToEffect.Clear();
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[2]
			{
				EffectType.Awful,
				EffectType.Bad
			});
			RollToEffect.Add(3, new EffectType[2]
			{
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(4, new EffectType[2]
			{
				EffectType.Mixed,
				EffectType.Good
			});
			RollToEffect.Add(5, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
			doGamblerRoll();
		}

		public void doGamblerRoll()
		{
			try
			{
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = Random.Range(1, 7);
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		public void setupRustyRoll()
		{
			RollToEffect.Clear();
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[2]
			{
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(3, new EffectType[0]);
			RollToEffect.Add(4, new EffectType[0]);
			RollToEffect.Add(5, new EffectType[0]);
			RollToEffect.Add(6, new EffectType[0]);
			doRustyRoll();
		}

		public void doRustyRoll()
		{
			//IL_0240: 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_02ac: 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_033c: 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)
			try
			{
				int num = Random.Range(1, 7);
				int num2 = Random.Range(1, 15);
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect == null)
				{
					switch (num)
					{
					case 3:
						if (MysteryDice.DebugLogging.Value)
						{
							MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 3");
						}
						Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(1, 2));
						Misc.SafeTipMessage("Rolled 3", "Spawning some scrap");
						break;
					case 4:
						if (MysteryDice.DebugLogging.Value)
						{
							MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 4");
						}
						Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(3, 4));
						Misc.SafeTipMessage("Rolled 4", "Spawning scrap");
						break;
					case 5:
						if (MysteryDice.DebugLogging.Value)
						{
							MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 5");
						}
						Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(5, 6));
						Misc.SafeTipMessage("Rolled 5", "Spawning more scrap");
						break;
					case 6:
					{
						RoundManager instance = RoundManager.Instance;
						List<int> list = new List<int>(instance.currentLevel.spawnableScrap.Count);
						for (int i = 0; i < instance.currentLevel.spawnableScrap.Count; i++)
						{
							list.Add(instance.currentLevel.spawnableScrap[i].rarity);
						}
						int[] array = list.ToArray();
						switch (num2)
						{
						case 1:
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 Eggs");
							}
							Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(4, 6), "Easter egg");
							Misc.SafeTipMessage("Hop Hop", "Explosive Eggs?");
							break;
						case 2:
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 Christmas");
							}
							Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(4, 7), "Gift");
							Misc.SafeTipMessage("HO HO HO", "Christmas Time!");
							break;
						case 3:
						{
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 SSDD");
							}
							Item spawnableItem = instance.currentLevel.spawnableScrap[instance.GetRandomWeightedIndex(array, (Random)null)].spawnableItem;
							Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(6, 8), spawnableItem.itemName);
							Misc.SafeTipMessage("Wat?", "It's all the same?!?");
							break;
						}
						default:
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 Normal");
							}
							Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(7, 8));
							Misc.SafeTipMessage("Rolled 6", "Spawning a lot of scrap!");
							break;
						}
						break;
					}
					}
				}
				else
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					ShowDefaultTooltip(randomEffect, num);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		public void setupSaintRoll()
		{
			RollToEffect.Clear();
			RollToEffect.Add(1, new EffectType[0]);
			RollToEffect.Add(2, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(3, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(4, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(5, new EffectType[1] { EffectType.Great });
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
			doSaintRoll();
		}

		public void doSaintRoll()
		{
			try
			{
				int num = Random.Range(1, 7);
				if (num == 1)
				{
					Misc.SafeTipMessage("Rolled 1", "Nothing happened");
					return;
				}
				IEffect randomEffect = GetRandomEffect(num, Effects);
				PlaySoundBasedOnEffect(randomEffect.Outcome);
				if (num == 6)
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Saint 6");
					}
					DebugMenuStuff.ShowSelectEffectMenu();
					Misc.SafeTipMessage("Rolled 6", "Choose an effect");
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				}
				else
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName2 = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName2, randomEffect.Name, num);
					Misc.SafeTipMessage($"Rolled {num}", randomEffect.Tooltip);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		public void setupSurfacedRoll()
		{
			RollToEffect.Clear();
			RollToEffect.Add(1, new EffectType[3]
			{
				EffectType.Awful,
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(2, new EffectType[3]
			{
				EffectType.Bad,
				EffectType.Awful,
				EffectType.Mixed
			});
			RollToEffect.Add(3, new EffectType[3]
			{
				EffectType.Mixed,
				EffectType.Bad,
				EffectType.Good
			});
			RollToEffect.Add(4, new EffectType[3]
			{
				EffectType.Good,
				EffectType.Mixed,
				EffectType.Bad
			});
			RollToEffect.Add(5, new EffectType[3]
			{
				EffectType.Good,
				EffectType.Great,
				EffectType.Mixed
			});
			RollToEffect.Add(6, new EffectType[3]
			{
				EffectType.Great,
				EffectType.Good,
				EffectType.Mixed
			});
			doSurfacedRoll();
		}

		public void doSurfacedRoll()
		{
			try
			{
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = Random.Range(1, 7);
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, MysteryDice.SurfacedPresent ? SurfacedEffects : Effects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		public void setupSacrificerRoll()
		{
			RollToEffect.Clear();
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[1]);
			RollToEffect.Add(3, new EffectType[2]
			{
				EffectType.Awful,
				EffectType.Bad
			});
			RollToEffect.Add(4, new EffectType[1] { EffectType.Bad });
			RollToEffect.Add(5, new EffectType[1] { EffectType.Bad });
			RollToEffect.Add(6, new EffectType[2]
			{
				EffectType.Mixed,
				EffectType.Bad
			});
			doSacrificerRoll();
		}

		public void doSacrificerRoll()
		{
			try
			{
				int num = Random.Range(1, 7);
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect == null)
				{
					return;
				}
				PlaySoundBasedOnEffect(randomEffect.Outcome);
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
				}
				randomEffect.Use();
				string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
				Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				if (num == 1)
				{
					Misc.SafeTipMessage("Rolled 1...", "Run");
					randomEffect = GetRandomEffect(num, Effects);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					playerName = (((Object)(object)PlayerUser != (Object)null) ? PlayerUser.playerUsername : "An Enemy");
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				}
				else
				{
					Misc.SafeTipMessage($"Rolled {num}", (randomEffect.Outcome == EffectType.Bad) ? "This could have been worse" : "Awful");
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
			new ReturnToShip().Use();
		}

		public void AprilFoolsRoll()
		{
			switch (Random.Range(0, 7))
			{
			case 0:
				setupChronosRoll();
				break;
			case 1:
				setupEmergencyRoll();
				break;
			case 2:
				setupSacrificerRoll();
				break;
			case 3:
				setupSaintRoll();
				break;
			case 4:
				setupGamblerRoll();
				break;
			case 5:
				setupSurfacedRoll();
				break;
			case 6:
				setupRustyRoll();
				break;
			default:
				RollToEffect.Clear();
				SetupRollToEffectMapping();
				Roll();
				break;
			}
			RollToEffect.Clear();
			SetupRollToEffectMapping();
		}

		protected override void __initializeVariables()
		{
			((PhysicsProp)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3757258078u, new RpcReceiveHandler(__rpc_handler_3757258078), "SyncDropServerRPC");
			((NetworkBehaviour)this).__registerRpc(1737949898u, new RpcReceiveHandler(__rpc_handler_1737949898), "SyncDropClientRPC");
			((PhysicsProp)this).__initializeRpcs();
		}

		private static void __rpc_handler_3757258078(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int timer = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref timer);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DieBehaviour)(object)target).SyncDropServerRPC(userID, timer);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1737949898(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int userID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref userID);
				int timer = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref timer);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DieBehaviour)(object)target).SyncDropClientRPC(userID, timer);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "DieBehaviour";
		}
	}
	public class EmergencyDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[1] { EffectType.Bad });
			RollToEffect.Add(3, new EffectType[1] { EffectType.Mixed });
			RollToEffect.Add(4, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(5, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
		}

		public override IEnumerator UseTimer(int userID, int time)
		{
			DiceModel.GetComponent<Blinking>().BlinkingTime = 0.1f;
			return base.UseTimer(userID, time);
		}

		public override void DestroyObject()
		{
			DiceModel.GetComponent<Blinking>()?.HideSigns();
			base.DestroyObject();
		}

		public override void Roll()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Roll Emergency");
			}
			int num = Random.Range(1, 7);
			try
			{
				IEffect effect = GetRandomEffect(num, Effects);
				if (effect == null)
				{
					return;
				}
				if (nextEffect == null)
				{
					if (num > 2)
					{
						effect = new ReturnToShip();
					}
					if (num == 6)
					{
						effect = new ReturnToShipTogether();
					}
				}
				PlaySoundBasedOnEffect(effect.Outcome);
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + effect.Name));
				}
				effect.Use();
				string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
				Networker.Instance.LogEffectsToOwnerServerRPC(playerName, effect.Name, num);
				DieBehaviour.ShowDefaultTooltip(effect, num);
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "EmergencyDie";
		}
	}
	public class GamblerDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[2]
			{
				EffectType.Awful,
				EffectType.Bad
			});
			RollToEffect.Add(3, new EffectType[2]
			{
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(4, new EffectType[2]
			{
				EffectType.Mixed,
				EffectType.Good
			});
			RollToEffect.Add(5, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
		}

		public override IEnumerator UseTimer(int userID, int Timer)
		{
			DiceModel.GetComponent<CycleSigns>().CycleTime = 0.1f;
			return base.UseTimer(userID, Timer);
		}

		public override void DestroyObject()
		{
			DiceModel.GetComponent<CycleSigns>().HideSigns();
			base.DestroyObject();
		}

		public override void Roll()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Roll Gambler");
			}
			try
			{
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = Random.Range(1, 7);
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						DieBehaviour.ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "GamblerDie";
		}
	}
	public class RustyDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[2]
			{
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(3, new EffectType[0]);
			RollToEffect.Add(4, new EffectType[0]);
			RollToEffect.Add(5, new EffectType[0]);
			RollToEffect.Add(6, new EffectType[0]);
		}

		public override void Roll()
		{
			//IL_0261: 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_02cd: 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_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Roll Rusty");
			}
			try
			{
				int num = Random.Range(1, 7);
				int num2 = Random.Range(1, 15);
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect == null)
				{
					switch (num)
					{
					case 3:
						if (MysteryDice.DebugLogging.Value)
						{
							MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 3");
						}
						Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(1, 2));
						Misc.SafeTipMessage("Rolled 3", "Spawning some scrap");
						break;
					case 4:
						if (MysteryDice.DebugLogging.Value)
						{
							MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 4");
						}
						Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(3, 4));
						Misc.SafeTipMessage("Rolled 4", "Spawning scrap");
						break;
					case 5:
						if (MysteryDice.DebugLogging.Value)
						{
							MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 5");
						}
						Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(5, 6));
						Misc.SafeTipMessage("Rolled 5", "Spawning more scrap");
						break;
					case 6:
					{
						RoundManager instance = RoundManager.Instance;
						List<int> list = new List<int>(instance.currentLevel.spawnableScrap.Count);
						for (int i = 0; i < instance.currentLevel.spawnableScrap.Count; i++)
						{
							list.Add(instance.currentLevel.spawnableScrap[i].rarity);
						}
						int[] array = list.ToArray();
						switch (num2)
						{
						case 1:
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 Eggs");
							}
							Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(4, 6), "Easter egg");
							Misc.SafeTipMessage("Hop Hop", "Explosive Eggs?");
							break;
						case 2:
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 Christmas");
							}
							Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(4, 7), "Gift");
							Misc.SafeTipMessage("HO HO HO", "Christmas Time!");
							break;
						case 3:
						{
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 SSDD");
							}
							Item spawnableItem = instance.currentLevel.spawnableScrap[instance.GetRandomWeightedIndex(array, (Random)null)].spawnableItem;
							Networker.Instance.SameScrapServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(6, 8), spawnableItem.itemName);
							Misc.SafeTipMessage("Wat?", "It's all the same?!?");
							break;
						}
						default:
							if (MysteryDice.DebugLogging.Value)
							{
								MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Rusty 6 Normal");
							}
							Networker.Instance.JackpotServerRPC(Array.IndexOf(StartOfRound.Instance.allPlayerScripts, PlayerUser), Random.Range(7, 8));
							Misc.SafeTipMessage("Rolled 6", "Spawning a lot of scrap!");
							break;
						}
						break;
					}
					}
				}
				else
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					DieBehaviour.ShowDefaultTooltip(randomEffect, num);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "RustyDie";
		}
	}
	public class SacrificerDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[1]);
			RollToEffect.Add(2, new EffectType[1]);
			RollToEffect.Add(3, new EffectType[2]
			{
				EffectType.Awful,
				EffectType.Bad
			});
			RollToEffect.Add(4, new EffectType[1] { EffectType.Bad });
			RollToEffect.Add(5, new EffectType[1] { EffectType.Bad });
			RollToEffect.Add(6, new EffectType[2]
			{
				EffectType.Mixed,
				EffectType.Bad
			});
		}

		public override void Roll()
		{
			try
			{
				int num = Random.Range(1, 7);
				IEffect randomEffect = GetRandomEffect(num, Effects);
				if (randomEffect == null)
				{
					return;
				}
				PlaySoundBasedOnEffect(randomEffect.Outcome);
				if (MysteryDice.DebugLogging.Value)
				{
					MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
				}
				randomEffect.Use();
				string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
				Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				if (num == 1)
				{
					Misc.SafeTipMessage("Rolled 1...", "Run");
					randomEffect = GetRandomEffect(num, Effects);
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					playerName = (((Object)(object)PlayerUser != (Object)null) ? PlayerUser.playerUsername : "An Enemy");
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				}
				else
				{
					Misc.SafeTipMessage($"Rolled {num}", EffectText(randomEffect.Outcome));
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
			new ReturnToShip().Use();
		}

		public string EffectText(EffectType effectType)
		{
			return effectType switch
			{
				EffectType.Bad => "This could have been worse", 
				EffectType.Awful => "Terrible", 
				_ => "", 
			};
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "SacrificerDie";
		}
	}
	public class SaintDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[0]);
			RollToEffect.Add(2, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(3, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(4, new EffectType[1] { EffectType.Good });
			RollToEffect.Add(5, new EffectType[1] { EffectType.Great });
			RollToEffect.Add(6, new EffectType[1] { EffectType.Great });
		}

		public override void Roll()
		{
			try
			{
				int num = Random.Range(1, 7);
				if (num == 1)
				{
					Misc.SafeTipMessage("Rolled 1", "Nothing happened");
					return;
				}
				IEffect randomEffect = GetRandomEffect(num, Effects);
				PlaySoundBasedOnEffect(randomEffect.Outcome);
				if (num == 6 && nextEffect == null)
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)"Rolling Effect: Saint 6");
					}
					DebugMenuStuff.ShowSelectEffectMenu();
					Misc.SafeTipMessage("Rolled 6", "Choose an effect");
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
				}
				else
				{
					if (MysteryDice.DebugLogging.Value)
					{
						MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					}
					randomEffect.Use();
					string playerName2 = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName2, randomEffect.Name, num);
					Misc.SafeTipMessage($"Rolled {num}", randomEffect.Tooltip);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "SaintDie";
		}
	}
	public class SteveLeDice : DieBehaviour
	{
		public OwnerNetworkAnimator NetworkAnimator;

		public Animator Animator;

		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[2]
			{
				EffectType.Awful,
				EffectType.Bad
			});
			RollToEffect.Add(2, new EffectType[2]
			{
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(3, new EffectType[3]
			{
				EffectType.Mixed,
				EffectType.Bad,
				EffectType.Good
			});
			RollToEffect.Add(4, new EffectType[3]
			{
				EffectType.Good,
				EffectType.Mixed,
				EffectType.Bad
			});
			RollToEffect.Add(5, new EffectType[2]
			{
				EffectType.Good,
				EffectType.Mixed
			});
			RollToEffect.Add(6, new EffectType[2]
			{
				EffectType.Great,
				EffectType.Good
			});
		}

		public override IEnumerator UseTimer(int userID, int spinTime)
		{
			if (((NetworkBehaviour)this).IsOwner)
			{
				((NetworkAnimator)NetworkAnimator).SetTrigger("use");
				Animator.SetBool("useBool", true);
			}
			Networker.Instance.RequestEmotesInRadiusServerRpc(((Component)this).transform.position, 10f);
			yield return ((MonoBehaviour)this).StartCoroutine(base.UseTimer(userID, 5));
		}

		public override void EquipItem()
		{
			base.EquipItem();
			if (((NetworkBehaviour)this).IsOwner)
			{
				Animator.SetBool("isHeld", true);
			}
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).DiscardItem();
			if (((NetworkBehaviour)this).IsOwner)
			{
				Animator.SetBool("isHeld", false);
			}
		}

		public override void Roll()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Roll Steve");
			}
			try
			{
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = Random.Range(1, 7);
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, SteveEffects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						DieBehaviour.ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "SteveLeDice";
		}
	}
	public class SurfacedDie : DieBehaviour
	{
		public override void SetupRollToEffectMapping()
		{
			RollToEffect.Add(1, new EffectType[3]
			{
				EffectType.Awful,
				EffectType.Bad,
				EffectType.Mixed
			});
			RollToEffect.Add(2, new EffectType[3]
			{
				EffectType.Bad,
				EffectType.Awful,
				EffectType.Mixed
			});
			RollToEffect.Add(3, new EffectType[3]
			{
				EffectType.Mixed,
				EffectType.Bad,
				EffectType.Good
			});
			RollToEffect.Add(4, new EffectType[3]
			{
				EffectType.Good,
				EffectType.Mixed,
				EffectType.Bad
			});
			RollToEffect.Add(5, new EffectType[3]
			{
				EffectType.Good,
				EffectType.Great,
				EffectType.Mixed
			});
			RollToEffect.Add(6, new EffectType[3]
			{
				EffectType.Great,
				EffectType.Good,
				EffectType.Mixed
			});
		}

		public override void Roll()
		{
			if (MysteryDice.DebugLogging.Value)
			{
				MysteryDice.CustomLogger.LogDebug((object)"Roll Surfaced");
			}
			try
			{
				bool flag = !GameNetworkManager.Instance.localPlayerController.isInsideFactory;
				int num = Random.Range(1, 7);
				if (flag && !MysteryDice.useDiceOutside.Value)
				{
					num = 1;
				}
				IEffect randomEffect = GetRandomEffect(num, MysteryDice.SurfacedPresent ? SurfacedEffects : Effects);
				if (randomEffect != null)
				{
					PlaySoundBasedOnEffect(randomEffect.Outcome);
					MysteryDice.CustomLogger.LogDebug((object)("Rolling Effect: " + randomEffect.Name));
					randomEffect.Use();
					string playerName = (wasCurse ? "A Cursed Player" : (wasEnemy ? "An Enemy" : (wasGhost ? "A ghost" : PlayerUser.playerUsername)));
					Networker.Instance.LogEffectsToOwnerServerRPC(playerName, randomEffect.Name, num);
					if (flag && !MysteryDice.useDiceOutside.Value)
					{
						Misc.SafeTipMessage("Penalty", "Next time roll it inside :)");
					}
					else
					{
						DieBehaviour.ShowDefaultTooltip(randomEffect, num);
					}
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("Roll error: " + ex));
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "SurfacedDie";
		}
	}
}
namespace MysteryDice.CompatThings
{
	public class CodeRebirthCheckConfigs
	{
		public static DawnMapObjectInfo getTrap(string trapName)
		{
			IEnumerable<KeyValuePair<NamespacedKey<DawnMapObjectInfo>, DawnMapObjectInfo>> enumerable = ((IEnumerable<KeyValuePair<NamespacedKey<DawnMapObjectInfo>, DawnMapObjectInfo>>)LethalContent.MapObjects).Where((KeyValuePair<NamespacedKey<DawnMapObjectInfo>, DawnMapObjectInfo> x) => ((Object)x.Value.GetMapObjectPrefab()).name == trapName);
			KeyValuePair<NamespacedKey<DawnMapObjectInfo>, DawnMapObjectInfo>[] source = (enumerable as KeyValuePair<NamespacedKey<DawnMapObjectInfo>, DawnMapObjectInfo>[]) ?? enumerable.ToArray();
			if (source.Count() == 0)
			{
				return null;
			}
			return source.First().Value;
		}

		public static EnemyType getEnemy(string enemyName)
		{
			IEnumerable<KeyValuePair<NamespacedKey<DawnEnemyInfo>, DawnEnemyInfo>> enumerable = ((IEnumerable<KeyValuePair<NamespacedKey<DawnEnemyInfo>, DawnEnemyInfo>>)LethalContent.Enemies).Where((KeyValuePair<NamespacedKey<DawnEnemyInfo>, DawnEnemyInfo> x) => x.Value.EnemyType.enemyName == enemyName);
			KeyValuePair<NamespacedKey<DawnEnemyInfo>, DawnEnemyInfo>[] source = (enumerable as KeyValuePair<NamespacedKey<DawnEnemyInfo>, DawnEnemyInfo>[]) ?? enumerable.ToArray();
			if (source.Count() == 0)
			{
				return null;
			}
			return source.First().Value.EnemyType;
		}

		public static void listAll()
		{
			try
			{
				foreach (KeyValuePair<NamespacedKey<DawnMapObjectInfo>, DawnMapObjectInfo> item in (Registry<DawnMapObjectInfo>)(object)LethalContent.MapObjects)
				{
					MysteryDice.ExtendedLogging("EDU Found Trap:" + ((Object)item.Value.GetMapObjectPrefab()).name, (LogLevel)16);
				}
				foreach (KeyValuePair<NamespacedKey<DawnEnemyInfo>, DawnEnemyInfo> item2 in (Registry<DawnEnemyInfo>)(object)LethalContent.Enemies)
				{
					MysteryDice.ExtendedLogging("EDU Found Enemy:" + item2.Value.EnemyType.enemyName, (LogLevel)16);
				}
			}
			catch (Exception ex)
			{
				MysteryDice.CustomLogger.LogError((object)("EDU Error: " + ex));
			}
		}

		public static List<trap> getSpawnPrefabs()
		{
			List<trap> list = new List<trap>();
			foreach (KeyValuePair<NamespacedKey<DawnMapObjectInfo>, DawnMapObjectInfo> item in (Registry<DawnMapObjectInfo>)(object)LethalContent.MapObjects)
			{
				MysteryDice.ExtendedLogging("added " + ((Object)item.Value.GetMapObjectPrefab()).name + " to traps", (LogLevel)16);
				list.Add(new trap(((Object)item.Value.GetMapObjectPrefab()).name, item.Value.GetMapObjectPrefab()));
			}
			return list;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace MysteryDice.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}