using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Profiling;
using UnityEngine;
using UnityEngine.Rendering;
using VPOBurst;
using ValheimPerformanceOptimizations.Extensions;
using ValheimPerformanceOptimizations.RuntimeDebugDraw.Internal;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValheimPerformanceOptimizations")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimPerformanceOptimizations")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("AD2F8A00-7A5E-460D-80ED-F48DF0221D8C")]
[assembly: AssemblyFileVersion("1.2.3")]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ValheimPerformanceOptimizations
{
	[HarmonyPatch]
	internal static class ModCompatibility
	{
		internal static bool IsHDTerrainPresent => Chainloader.PluginInfos.ContainsKey("Badgers.ValheimHDTerrain");

		internal static void Initialize()
		{
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private static void InitTerrainCompat()
		{
		}
	}
	public static class ThreadedWorldLoadingPatch
	{
	}
	public static class AssetBundleHelper
	{
		public static AssetBundle GetAssetBundleFromResources(string fileName)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(fileName));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}
	}
	public static class BurstLoader
	{
		public const string WindowsBurstLibraryFileName = "VPOBurst_win_x86_64.dll";

		public const string LinuxBurstLibraryFileName = "VPOBurst_linux_x86_64.so";

		public static bool LibraryLoaded { get; private set; }

		public static bool JobsAreBursted { get; private set; }

		public static void Initialize()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (string.IsNullOrEmpty(directoryName))
			{
				ValheimPerformanceOptimizations.Logger.LogWarning((object)"VPO Burst: could not resolve plugin directory");
				return;
			}
			string text = (((int)Application.platform != 2) ? (((int)Application.platform == 13 || (int)Application.platform == 43) ? "VPOBurst_linux_x86_64.so" : null) : "VPOBurst_win_x86_64.dll");
			if (text == null)
			{
				ValheimPerformanceOptimizations.Logger.LogWarning((object)$"VPO Burst: unsupported Unity platform '{Application.platform}'");
				return;
			}
			string text2 = Path.Combine(directoryName, text);
			if (!File.Exists(text2))
			{
				ValheimPerformanceOptimizations.Logger.LogWarning((object)("VPO Burst: missing '" + text + "' next to the plugin."));
				return;
			}
			LibraryLoaded = BurstRuntime.LoadAdditionalLibrary(text2);
			if (!LibraryLoaded)
			{
				ValheimPerformanceOptimizations.Logger.LogWarning((object)("VPO Burst: BurstRuntime.LoadAdditionalLibrary failed for '" + text2 + "'"));
			}
			JobsAreBursted = ProbeIsBursted();
			if (JobsAreBursted)
			{
				ValheimPerformanceOptimizations.Logger.LogInfo((object)"VPO Burst: Burst jobs are enabled");
			}
			else
			{
				ValheimPerformanceOptimizations.Logger.LogWarning((object)"VPO Burst: Burst jobs are disabled");
			}
		}

		private static string GetBurstLibraryFileName()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if ((int)Application.platform == 2)
			{
				return "VPOBurst_win_x86_64.dll";
			}
			if ((int)Application.platform == 13)
			{
				return "VPOBurst_linux_x86_64.so";
			}
			return null;
		}

		public static bool ProbeIsBursted()
		{
			//IL_000c: 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)
			NativeArray<int> flag = default(NativeArray<int>);
			flag..ctor(1, (Allocator)3, (NativeArrayOptions)0);
			try
			{
				IJobExtensions.Run<CheckBurstedJob>(new CheckBurstedJob
				{
					Flag = flag
				});
				return flag[0] == 1;
			}
			finally
			{
				flag.Dispose();
			}
		}
	}
	public class BoundsOctree<T>
	{
		private BoundsOctreeNode<T> rootNode;

		private readonly float looseness;

		private readonly float initialSize;

		private readonly float minSize;

		public int Count { get; private set; }

		public BoundsOctree(float initialWorldSize, Vector3 initialWorldPos, float minNodeSize, float loosenessVal, IEqualityComparer<T> comparer = null)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (minNodeSize > initialWorldSize)
			{
				Debug.LogWarning((object)("Minimum node size must be at least as big as the initial world size. Was: " + minNodeSize + " Adjusted to: " + initialWorldSize));
				minNodeSize = initialWorldSize;
			}
			Count = 0;
			initialSize = initialWorldSize;
			minSize = minNodeSize;
			looseness = Mathf.Clamp(loosenessVal, 1f, 2f);
			rootNode = new BoundsOctreeNode<T>(initialSize, minSize, looseness, initialWorldPos, comparer);
		}

		public void Add(T obj, Bounds objBounds)
		{
			//IL_0051: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			while (!rootNode.Add(obj, objBounds))
			{
				Grow(((Bounds)(ref objBounds)).center - rootNode.Center);
				if (++num > 20)
				{
					Debug.LogError((object)("Aborted Add operation as it seemed to be going on forever (" + (num - 1) + ") attempts at growing the octree."));
					return;
				}
			}
			Count++;
		}

		public bool Remove(T obj)
		{
			bool num = rootNode.Remove(obj);
			if (num)
			{
				Count--;
				Shrink();
			}
			return num;
		}

		public bool Remove(T obj, Bounds objBounds)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			bool num = rootNode.Remove(obj, objBounds);
			if (num)
			{
				Count--;
				Shrink();
			}
			return num;
		}

		public bool IsColliding(Bounds checkBounds)
		{
			return rootNode.IsColliding(ref checkBounds);
		}

		public bool IsColliding(Ray checkRay, float maxDistance)
		{
			return rootNode.IsColliding(ref checkRay, maxDistance);
		}

		public void GetOverlapping(List<T> collidingWith, Bounds checkBounds)
		{
			rootNode.GetOverlapping(ref checkBounds, collidingWith);
		}

		public void GetOverlapping(List<T> collidingWith, Vector3 center, float radius)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			rootNode.GetOverlapping(center, radius, collidingWith);
		}

		public void GetOverlappingXZ(List<T> collidingWith, Bounds checkBounds)
		{
			rootNode.GetOverlappingXZ(ref checkBounds, collidingWith);
		}

		public void GetOverlapping(List<T> collidingWith, Ray checkRay, float maxDistance = float.PositiveInfinity)
		{
			rootNode.GetColliding(ref checkRay, collidingWith, maxDistance);
		}

		public List<T> GetWithinFrustum(Camera cam)
		{
			Plane[] planes = GeometryUtility.CalculateFrustumPlanes(cam);
			List<T> result = new List<T>();
			rootNode.GetWithinFrustum(planes, result);
			return result;
		}

		public Bounds GetMaxBounds()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return rootNode.GetBounds();
		}

		public void DrawAllBounds()
		{
			rootNode.DrawAllBounds();
		}

		public void DrawAllObjects()
		{
			rootNode.DrawAllObjects();
		}

		private void Grow(Vector3 direction)
		{
			//IL_0000: 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_0024: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_011d: 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)
			int num = ((direction.x >= 0f) ? 1 : (-1));
			int num2 = ((direction.y >= 0f) ? 1 : (-1));
			int num3 = ((direction.z >= 0f) ? 1 : (-1));
			BoundsOctreeNode<T> boundsOctreeNode = rootNode;
			float num4 = rootNode.BaseLength / 2f;
			float baseLengthVal = rootNode.BaseLength * 2f;
			Vector3 val = rootNode.Center + new Vector3((float)num * num4, (float)num2 * num4, (float)num3 * num4);
			rootNode = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, val);
			if (!boundsOctreeNode.HasAnyObjects())
			{
				return;
			}
			int num5 = rootNode.BestFitChild(boundsOctreeNode.Center);
			BoundsOctreeNode<T>[] array = new BoundsOctreeNode<T>[8];
			for (int i = 0; i < 8; i++)
			{
				if (i == num5)
				{
					array[i] = boundsOctreeNode;
					continue;
				}
				num = ((i % 2 != 0) ? 1 : (-1));
				num2 = ((i <= 3) ? 1 : (-1));
				num3 = ((i >= 2 && (i <= 3 || i >= 6)) ? 1 : (-1));
				array[i] = new BoundsOctreeNode<T>(boundsOctreeNode.BaseLength, minSize, looseness, val + new Vector3((float)num * num4, (float)num2 * num4, (float)num3 * num4));
			}
			rootNode.SetChildren(array);
		}

		private void Shrink()
		{
			rootNode = rootNode.ShrinkIfPossible(initialSize);
		}
	}
	public class BoundsOctreeNode<T>
	{
		private struct OctreeObject
		{
			public T Obj;

			public Bounds Bounds;
		}

		private float looseness;

		private float minSize;

		private float adjLength;

		private Bounds bounds;

		private readonly List<OctreeObject> objects = new List<OctreeObject>();

		private BoundsOctreeNode<T>[] children;

		private Bounds[] childBounds;

		private IEqualityComparer<T> comparator;

		private const int NUM_OBJECTS_ALLOWED = 8;

		public Vector3 Center { get; private set; }

		public float BaseLength { get; private set; }

		private bool HasChildren => children != null;

		public BoundsOctreeNode(float baseLengthVal, float minSizeVal, float loosenessVal, Vector3 centerVal, IEqualityComparer<T> comparer = null)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			SetValues(baseLengthVal, minSizeVal, loosenessVal, centerVal, comparer);
		}

		public bool Add(T obj, Bounds objBounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!Encapsulates(bounds, objBounds))
			{
				return false;
			}
			SubAdd(obj, objBounds);
			return true;
		}

		public bool Remove(T obj)
		{
			bool flag = false;
			for (int i = 0; i < objects.Count; i++)
			{
				if (comparator.Equals(objects[i].Obj, obj))
				{
					objects.RemoveAtSwapBack(i);
					flag = true;
					break;
				}
			}
			if (!flag && children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					flag = children[j].Remove(obj);
					if (flag)
					{
						break;
					}
				}
			}
			if (flag && children != null && ShouldMerge())
			{
				Merge();
			}
			return flag;
		}

		public bool Remove(T obj, Bounds objBounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!Encapsulates(bounds, objBounds))
			{
				return false;
			}
			return SubRemove(obj, objBounds, parentContained: false);
		}

		public int RemoveAll(Bounds objBounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!Encapsulates(bounds, objBounds))
			{
				return 0;
			}
			return SubRemoveAll(objBounds);
		}

		public bool IsColliding(ref Bounds checkBounds)
		{
			//IL_0007: 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 (!((Bounds)(ref bounds)).Intersects(checkBounds))
			{
				return false;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				OctreeObject octreeObject = objects[i];
				if (((Bounds)(ref octreeObject.Bounds)).Intersects(checkBounds))
				{
					return true;
				}
			}
			if (children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					if (children[j].IsColliding(ref checkBounds))
					{
						return true;
					}
				}
			}
			return false;
		}

		public bool IsColliding(ref Ray checkRay, float maxDistance = float.PositiveInfinity)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			if (!((Bounds)(ref bounds)).IntersectRay(checkRay, ref num) || num > maxDistance)
			{
				return false;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				OctreeObject octreeObject = objects[i];
				if (((Bounds)(ref octreeObject.Bounds)).IntersectRay(checkRay, ref num) && num <= maxDistance)
				{
					return true;
				}
			}
			if (children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					if (children[j].IsColliding(ref checkRay, maxDistance))
					{
						return true;
					}
				}
			}
			return false;
		}

		public void GetOverlapping(ref Bounds checkBounds, List<T> result)
		{
			//IL_0007: 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)
			if (!((Bounds)(ref bounds)).Intersects(checkBounds))
			{
				return;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				OctreeObject octreeObject = objects[i];
				if (((Bounds)(ref octreeObject.Bounds)).Intersects(checkBounds))
				{
					result.Add(objects[i].Obj);
				}
			}
			if (children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					children[j].GetOverlapping(ref checkBounds, result);
				}
			}
		}

		public void GetOverlapping(Vector3 center, float radius, List<T> collidingWith)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!bounds.IntersectsSphere(center, radius))
			{
				return;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				if (objects[i].Bounds.IntersectsSphere(center, radius))
				{
					collidingWith.Add(objects[i].Obj);
				}
			}
			if (children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					children[j].GetOverlapping(center, radius, collidingWith);
				}
			}
		}

		public void GetOverlappingXZ(ref Bounds checkBounds, List<T> result)
		{
			//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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!bounds.IntersectsXZ(checkBounds))
			{
				return;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				if (objects[i].Bounds.IntersectsXZ(checkBounds))
				{
					result.Add(objects[i].Obj);
				}
			}
			if (children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					children[j].GetOverlappingXZ(ref checkBounds, result);
				}
			}
		}

		public void GetColliding(ref Ray checkRay, List<T> result, float maxDistance = float.PositiveInfinity)
		{
			//IL_0007: 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)
			float num = default(float);
			if (!((Bounds)(ref bounds)).IntersectRay(checkRay, ref num) || num > maxDistance)
			{
				return;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				OctreeObject octreeObject = objects[i];
				if (((Bounds)(ref octreeObject.Bounds)).IntersectRay(checkRay, ref num) && num <= maxDistance)
				{
					result.Add(objects[i].Obj);
				}
			}
			if (children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					children[j].GetColliding(ref checkRay, result, maxDistance);
				}
			}
		}

		public void GetWithinFrustum(Plane[] planes, List<T> result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!GeometryUtility.TestPlanesAABB(planes, bounds))
			{
				return;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				if (GeometryUtility.TestPlanesAABB(planes, objects[i].Bounds))
				{
					result.Add(objects[i].Obj);
				}
			}
			if (children != null)
			{
				for (int j = 0; j < 8; j++)
				{
					children[j].GetWithinFrustum(planes, result);
				}
			}
		}

		public void SetChildren(BoundsOctreeNode<T>[] childOctrees)
		{
			if (childOctrees.Length != 8)
			{
				Debug.LogError((object)("Child octree array must be length 8. Was length: " + childOctrees.Length));
			}
			else
			{
				children = childOctrees;
			}
		}

		public Bounds GetBounds()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return bounds;
		}

		public void DrawAllBounds(float depth = 0f)
		{
			//IL_0015: 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_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_0069: Unknown result type (might be due to invalid IL or missing references)
			float num = depth / 7f;
			new Color(num, 0f, 1f - num);
			new Bounds(Center, new Vector3(adjLength, adjLength, adjLength));
			if (children != null)
			{
				depth += 1f;
				for (int i = 0; i < 8; i++)
				{
					children[i].DrawAllBounds(depth);
				}
			}
			Gizmos.color = Color.white;
		}

		public void DrawAllObjects()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_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_0056: 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)
			float num = BaseLength / 20f;
			Gizmos.color = new Color(0f, 1f - num, num, 0.25f);
			foreach (OctreeObject @object in objects)
			{
				Bounds val = @object.Bounds;
				Vector3 center = ((Bounds)(ref val)).center;
				val = @object.Bounds;
				Gizmos.DrawCube(center, ((Bounds)(ref val)).size);
			}
			if (children != null)
			{
				for (int i = 0; i < 8; i++)
				{
					children[i].DrawAllObjects();
				}
			}
			Gizmos.color = Color.white;
		}

		public BoundsOctreeNode<T> ShrinkIfPossible(float minLength)
		{
			//IL_004c: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			if (BaseLength < 2f * minLength)
			{
				return this;
			}
			if (objects.Count == 0 && (children == null || children.Length == 0))
			{
				return this;
			}
			int num = -1;
			for (int i = 0; i < objects.Count; i++)
			{
				OctreeObject octreeObject = objects[i];
				int num2 = BestFitChild(((Bounds)(ref octreeObject.Bounds)).center);
				if (i == 0 || num2 == num)
				{
					if (Encapsulates(childBounds[num2], octreeObject.Bounds))
					{
						if (num < 0)
						{
							num = num2;
						}
						continue;
					}
					return this;
				}
				return this;
			}
			if (children != null)
			{
				bool flag = false;
				for (int j = 0; j < children.Length; j++)
				{
					if (children[j].HasAnyObjects())
					{
						if (flag)
						{
							return this;
						}
						if (num >= 0 && num != j)
						{
							return this;
						}
						flag = true;
						num = j;
					}
				}
			}
			if (children == null)
			{
				SetValues(BaseLength / 2f, minSize, looseness, ((Bounds)(ref childBounds[num])).center);
				return this;
			}
			if (num == -1)
			{
				return this;
			}
			return children[num];
		}

		public int BestFitChild(Vector3 objBoundsCenter)
		{
			//IL_0000: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			return ((!(objBoundsCenter.x <= Center.x)) ? 1 : 0) + ((!(objBoundsCenter.y >= Center.y)) ? 4 : 0) + ((!(objBoundsCenter.z <= Center.z)) ? 2 : 0);
		}

		public bool HasAnyObjects()
		{
			if (objects.Count > 0)
			{
				return true;
			}
			if (children != null)
			{
				for (int i = 0; i < 8; i++)
				{
					if (children[i].HasAnyObjects())
					{
						return true;
					}
				}
			}
			return false;
		}

		private void SetValues(float baseLengthVal, float minSizeVal, float loosenessVal, Vector3 centerVal, IEqualityComparer<T> comparer = null)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_00bc: 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_00cf: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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)
			//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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0190: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			BaseLength = baseLengthVal;
			minSize = minSizeVal;
			looseness = loosenessVal;
			Center = centerVal;
			adjLength = looseness * baseLengthVal;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(adjLength, adjLength, adjLength);
			bounds = new Bounds(Center, val);
			float num = BaseLength / 4f;
			float num2 = BaseLength / 2f * looseness;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(num2, num2, num2);
			childBounds = (Bounds[])(object)new Bounds[8];
			childBounds[0] = new Bounds(Center + new Vector3(0f - num, num, 0f - num), val2);
			childBounds[1] = new Bounds(Center + new Vector3(num, num, 0f - num), val2);
			childBounds[2] = new Bounds(Center + new Vector3(0f - num, num, num), val2);
			childBounds[3] = new Bounds(Center + new Vector3(num, num, num), val2);
			childBounds[4] = new Bounds(Center + new Vector3(0f - num, 0f - num, 0f - num), val2);
			childBounds[5] = new Bounds(Center + new Vector3(num, 0f - num, 0f - num), val2);
			childBounds[6] = new Bounds(Center + new Vector3(0f - num, 0f - num, num), val2);
			childBounds[7] = new Bounds(Center + new Vector3(num, 0f - num, num), val2);
			comparator = comparer ?? EqualityComparer<T>.Default;
		}

		private void SubAdd(T obj, Bounds objBounds)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (!HasChildren)
			{
				if (objects.Count < 8 || BaseLength / 2f < minSize)
				{
					OctreeObject item = new OctreeObject
					{
						Obj = obj,
						Bounds = objBounds
					};
					objects.Add(item);
					return;
				}
				if (children == null)
				{
					Split();
					if (children == null)
					{
						Debug.LogError((object)"Child creation failed for an unknown reason. Early exit.");
						return;
					}
					for (int num = objects.Count - 1; num >= 0; num--)
					{
						OctreeObject item2 = objects[num];
						int num2 = BestFitChild(((Bounds)(ref item2.Bounds)).center);
						if (Encapsulates(children[num2].bounds, item2.Bounds))
						{
							children[num2].SubAdd(item2.Obj, item2.Bounds);
							objects.Remove(item2);
						}
					}
				}
			}
			int num3 = BestFitChild(((Bounds)(ref objBounds)).center);
			if (Encapsulates(children[num3].bounds, objBounds))
			{
				children[num3].SubAdd(obj, objBounds);
				return;
			}
			OctreeObject item3 = new OctreeObject
			{
				Obj = obj,
				Bounds = objBounds
			};
			objects.Add(item3);
		}

		private bool SubRemove(T obj, Bounds objBounds, bool parentContained)
		{
			//IL_005d: 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_0085: 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_00ac: 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_00e3: 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)
			bool flag = false;
			for (int i = 0; i < objects.Count; i++)
			{
				OctreeObject octreeObject = objects[i];
				if (comparator.Equals(octreeObject.Obj, obj))
				{
					objects.RemoveAtSwapBack(i);
					flag = true;
					break;
				}
			}
			if (!flag && children != null)
			{
				int num = BestFitChild(((Bounds)(ref objBounds)).center);
				BoundsOctreeNode<T> boundsOctreeNode = children[num];
				if (((Bounds)(ref objBounds)).Intersects(boundsOctreeNode.bounds))
				{
					flag = boundsOctreeNode.SubRemove(obj, objBounds, parentContained);
				}
				if (!flag)
				{
					for (int j = 0; j < children.Length; j++)
					{
						if (num == j)
						{
							continue;
						}
						boundsOctreeNode = children[j];
						bool flag2 = parentContained;
						if (!flag2)
						{
							if (Encapsulates(objBounds, boundsOctreeNode.bounds))
							{
								flag2 = true;
							}
							else if (!((Bounds)(ref objBounds)).Intersects(boundsOctreeNode.bounds))
							{
								continue;
							}
						}
						if (((Bounds)(ref objBounds)).Intersects(boundsOctreeNode.bounds))
						{
							flag = boundsOctreeNode.SubRemove(obj, objBounds, flag2);
							if (flag)
							{
								break;
							}
						}
					}
				}
			}
			if (flag && children != null && ShouldMerge())
			{
				Merge();
			}
			return flag;
		}

		private int SubRemoveAll(Bounds objBounds)
		{
			//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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			int num = objects.RemoveAll((OctreeObject obj) => ((Bounds)(ref obj.Bounds)).Intersects(objBounds));
			if (num < 1 && children != null)
			{
				int num2 = BestFitChild(((Bounds)(ref objBounds)).center);
				num = children[num2].SubRemoveAll(objBounds);
			}
			if (num > 0 && children != null && ShouldMerge())
			{
				Merge();
			}
			return num;
		}

		private void Split()
		{
			//IL_003b: 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_006b: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			float num = BaseLength / 4f;
			float baseLengthVal = BaseLength / 2f;
			children = new BoundsOctreeNode<T>[8];
			children[0] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(0f - num, num, 0f - num));
			children[1] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(num, num, 0f - num));
			children[2] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(0f - num, num, num));
			children[3] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(num, num, num));
			children[4] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(0f - num, 0f - num, 0f - num));
			children[5] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(num, 0f - num, 0f - num));
			children[6] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(0f - num, 0f - num, num));
			children[7] = new BoundsOctreeNode<T>(baseLengthVal, minSize, looseness, Center + new Vector3(num, 0f - num, num));
		}

		private void Merge()
		{
			for (int i = 0; i < 8; i++)
			{
				BoundsOctreeNode<T> boundsOctreeNode = children[i];
				for (int num = boundsOctreeNode.objects.Count - 1; num >= 0; num--)
				{
					OctreeObject item = boundsOctreeNode.objects[num];
					objects.Add(item);
				}
			}
			children = null;
		}

		private static bool Encapsulates(Bounds outerBounds, Bounds innerBounds)
		{
			//IL_0004: 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)
			if (((Bounds)(ref outerBounds)).Contains(((Bounds)(ref innerBounds)).min))
			{
				return ((Bounds)(ref outerBounds)).Contains(((Bounds)(ref innerBounds)).max);
			}
			return false;
		}

		private bool ShouldMerge()
		{
			int num = objects.Count;
			if (children != null)
			{
				BoundsOctreeNode<T>[] array = children;
				foreach (BoundsOctreeNode<T> boundsOctreeNode in array)
				{
					if (boundsOctreeNode.children != null)
					{
						return false;
					}
					num += boundsOctreeNode.objects.Count;
				}
			}
			return num <= 8;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("dev.ontrigger.vpo", "Valheim Performance Optimizations", "1.2.3")]
	public class ValheimPerformanceOptimizations : BaseUnityPlugin
	{
		public const string PluginId = "dev.ontrigger.vpo";

		public const string PluginVersion = "1.2.3";

		internal const string ValheimRaftId = "BepIn.Sarcen.ValheimRAFT";

		internal const string JotunnId = "com.jotunn.jotunn";

		internal const string HDTerrain = "Badgers.ValheimHDTerrain";

		private static ValheimPerformanceOptimizations _instance;

		private Harmony _harmony;

		internal static ManualLogSource Logger { get; private set; }

		public static event Action<ConfigFile, Harmony> OnInitialized;

		private ValheimPerformanceOptimizations()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
		}

		private void Awake()
		{
			_instance = this;
			BurstLoader.Initialize();
			_harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "dev.ontrigger.vpo");
			CollectionExtensions.Do<Type>((IEnumerable<Type>)AccessTools.GetTypesFromAssembly(Assembly.GetExecutingAssembly()), (Action<Type>)delegate(Type type)
			{
				if (type.IsAbstract && type.IsSealed && type.GetConstructor(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, Array.Empty<ParameterModifier>()) != null)
				{
					RuntimeHelpers.RunClassConstructor(type.TypeHandle);
				}
			});
			ModCompatibility.Initialize();
			ValheimPerformanceOptimizations.OnInitialized?.Invoke(((BaseUnityPlugin)this).Config, _harmony);
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "ValheimPerformanceOptimizations";

		public const string PLUGIN_NAME = "ValheimPerformanceOptimizations";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ValheimPerformanceOptimizations.Storage
{
	public class ObjectPool<T> where T : new()
	{
		private readonly Stack<T> pool = new Stack<T>();

		private readonly Action<T> onRetrieve;

		private readonly Action<T> onReturn;

		public ObjectPool(Action<T> onRetrieve = null, Action<T> onReturn = null)
		{
			this.onRetrieve = onRetrieve;
			this.onReturn = onReturn;
		}

		public T Get()
		{
			T val = ((pool.Count == 0) ? new T() : pool.Pop());
			onRetrieve?.Invoke(val);
			return val;
		}

		public void Return(T toReturn)
		{
			onReturn?.Invoke(toReturn);
			pool.Push(toReturn);
		}
	}
	public static class SetPool<T>
	{
		private static readonly ObjectPool<HashSet<T>> Pool = new ObjectPool<HashSet<T>>(null, Clear);

		public static HashSet<T> Get()
		{
			return Pool.Get();
		}

		public static void Return(HashSet<T> toReturn)
		{
			Pool.Return(toReturn);
		}

		private static void Clear(HashSet<T> set)
		{
			set.Clear();
		}
	}
}
namespace ValheimPerformanceOptimizations.RuntimeDebugDraw
{
	public static class Draw
	{
		public const int DrawLineLayer = 4;

		public const int DrawTextDefaultSize = 12;

		public static Color DrawDefaultColor = Color.white;

		private static global::ValheimPerformanceOptimizations.RuntimeDebugDraw.Internal.RuntimeDebugDraw _rtDraw;

		private static string HIDDEN_GO_NAME = "________HIDDEN_C4F6A87F298241078E21C0D7C1D87A76_";

		public static Camera GetDebugDrawCamera()
		{
			return Camera.main;
		}

		[Conditional("_DEBUG")]
		public static void DrawLine(Vector3 start, Vector3 end, Color color, float duration, bool depthTest)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			CheckAndBuildHiddenRTDrawObject();
			_rtDraw.RegisterLine(start, end, color, duration, !depthTest);
		}

		[Conditional("_DEBUG")]
		public static void DrawRay(Vector3 start, Vector3 dir, Color color, float duration, bool depthTest)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			CheckAndBuildHiddenRTDrawObject();
			_rtDraw.RegisterLine(start, start + dir, color, duration, !depthTest);
		}

		[Conditional("_DEBUG")]
		public static void DrawText(Vector3 pos, string text, Color color, int size, float duration, bool popUp)
		{
			//IL_000a: 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)
			CheckAndBuildHiddenRTDrawObject();
			_rtDraw.RegisterDrawText(pos, text, color, size, duration, popUp);
		}

		[Conditional("_DEBUG")]
		public static void AttachText(Transform transform, Func<string> strFunc, Vector3 offset, Color color, int size)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			CheckAndBuildHiddenRTDrawObject();
			_rtDraw.RegisterAttachText(transform, strFunc, offset, color, size);
		}

		[Conditional("_DEBUG")]
		public static void DrawLine(Vector3 start, Vector3 end)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawLine(Vector3 start, Vector3 end, Color color)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawLine(Vector3 start, Vector3 end, Color color, float duration)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawBounds(Bounds b, Color color, float duration)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_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)
			//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_0098: 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_00aa: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0116: 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_0128: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			new Vector3(((Bounds)(ref b)).min.x, ((Bounds)(ref b)).min.y, ((Bounds)(ref b)).min.z);
			new Vector3(((Bounds)(ref b)).max.x, ((Bounds)(ref b)).min.y, ((Bounds)(ref b)).min.z);
			new Vector3(((Bounds)(ref b)).max.x, ((Bounds)(ref b)).min.y, ((Bounds)(ref b)).max.z);
			new Vector3(((Bounds)(ref b)).min.x, ((Bounds)(ref b)).min.y, ((Bounds)(ref b)).max.z);
			new Vector3(((Bounds)(ref b)).min.x, ((Bounds)(ref b)).max.y, ((Bounds)(ref b)).min.z);
			new Vector3(((Bounds)(ref b)).max.x, ((Bounds)(ref b)).max.y, ((Bounds)(ref b)).min.z);
			new Vector3(((Bounds)(ref b)).max.x, ((Bounds)(ref b)).max.y, ((Bounds)(ref b)).max.z);
			new Vector3(((Bounds)(ref b)).min.x, ((Bounds)(ref b)).max.y, ((Bounds)(ref b)).max.z);
		}

		[Conditional("_DEBUG")]
		public static void DrawRay(Vector3 start, Vector3 dir)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawRay(Vector3 start, Vector3 dir, Color color)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawRay(Vector3 start, Vector3 dir, Color color, float duration)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawText(Vector3 pos, string text)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawText(Vector3 pos, string text, Color color)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawText(Vector3 pos, string text, Color color, int size)
		{
		}

		[Conditional("_DEBUG")]
		public static void DrawText(Vector3 pos, string text, Color color, int size, float duration)
		{
		}

		[Conditional("_DEBUG")]
		public static void AttachText(Transform transform, Func<string> strFunc)
		{
		}

		[Conditional("_DEBUG")]
		public static void AttachText(Transform transform, Func<string> strFunc, Vector3 offset)
		{
		}

		[Conditional("_DEBUG")]
		public static void AttachText(Transform transform, Func<string> strFunc, Vector3 offset, Color color)
		{
		}

		private static void CheckAndBuildHiddenRTDrawObject()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			if ((Object)(object)_rtDraw != (Object)null)
			{
				return;
			}
			_rtDraw = Object.FindObjectOfType<global::ValheimPerformanceOptimizations.RuntimeDebugDraw.Internal.RuntimeDebugDraw>();
			if (!((Object)(object)_rtDraw != (Object)null))
			{
				GameObject val = new GameObject(HIDDEN_GO_NAME);
				GameObject val2 = new GameObject(HIDDEN_GO_NAME);
				val2.transform.parent = val.transform;
				_rtDraw = val2.AddComponent<global::ValheimPerformanceOptimizations.RuntimeDebugDraw.Internal.RuntimeDebugDraw>();
				((Object)val).hideFlags = (HideFlags)61;
				if (Application.isPlaying)
				{
					Object.DontDestroyOnLoad((Object)(object)val);
				}
			}
		}
	}
}
namespace ValheimPerformanceOptimizations.RuntimeDebugDraw.Internal
{
	internal class RuntimeDebugDraw : MonoBehaviour
	{
		private class DrawLineEntry
		{
			public bool occupied;

			public Vector3 start;

			public Vector3 end;

			public Color color;

			public float timer;

			public bool noZTest;
		}

		private class BatchedLineDraw : IDisposable
		{
			public Mesh mesh;

			public Material mat;

			private List<Vector3> _vertices;

			private List<Color> _colors;

			private List<int> _indices;

			public BatchedLineDraw(bool depthTest)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				mesh = new Mesh();
				mesh.MarkDynamic();
				mat = new Material(Shader.Find("Hidden/Internal-Colored"));
				mat.SetInt("_ZTest", depthTest ? 4 : 0);
				_vertices = new List<Vector3>();
				_colors = new List<Color>();
				_indices = new List<int>();
			}

			public void AddLine(Vector3 from, Vector3 to, Color color)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				_vertices.Add(from);
				_vertices.Add(to);
				_colors.Add(color);
				_colors.Add(color);
				int count = _vertices.Count;
				_indices.Add(count - 2);
				_indices.Add(count - 1);
			}

			public void Clear()
			{
				mesh.Clear();
				_vertices.Clear();
				_colors.Clear();
				_indices.Clear();
			}

			public void BuildBatch()
			{
				mesh.SetVertices(_vertices);
				mesh.SetColors(_colors);
				mesh.SetIndices(_indices.ToArray(), (MeshTopology)3, 0);
			}

			public void Dispose()
			{
				Object.DestroyImmediate((Object)(object)mesh);
				Object.DestroyImmediate((Object)(object)mat);
			}
		}

		[Flags]
		public enum DrawFlag : byte
		{
			None = 0,
			DrawnGizmo = 1,
			DrawnGUI = 2,
			DrawnAll = 3
		}

		private class DrawTextEntry
		{
			public bool occupied;

			public GUIContent content;

			public Vector3 anchor;

			public int size;

			public Color color;

			public float timer;

			public bool popUp;

			public float duration;

			public DrawFlag flag;

			public DrawTextEntry()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				content = new GUIContent();
			}
		}

		private class AttachTextEntry
		{
			public bool occupied;

			public GUIContent content;

			public Vector3 offset;

			public int size;

			public Color color;

			public Transform transform;

			public Func<string> strFunc;

			public DrawFlag flag;

			public AttachTextEntry()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				content = new GUIContent();
			}
		}

		private List<DrawLineEntry> _lineEntries;

		private BatchedLineDraw _ZTestBatch;

		private BatchedLineDraw _AlwaysBatch;

		private bool _linesNeedRebuild;

		private List<DrawTextEntry> _drawTextEntries;

		private List<AttachTextEntry> _attachTextEntries;

		private GUIStyle _textStyle;

		private void CheckInitialized()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (_drawTextEntries == null)
			{
				_ZTestBatch = new BatchedLineDraw(depthTest: true);
				_AlwaysBatch = new BatchedLineDraw(depthTest: false);
				_lineEntries = new List<DrawLineEntry>(16);
				_textStyle = new GUIStyle();
				_textStyle.alignment = (TextAnchor)0;
				_drawTextEntries = new List<DrawTextEntry>(16);
				_attachTextEntries = new List<AttachTextEntry>(16);
			}
		}

		private void Awake()
		{
			CheckInitialized();
		}

		private void OnGUI()
		{
			DrawTextOnGUI();
		}

		private void LateUpdate()
		{
			TickAndDrawLines();
			TickTexts();
		}

		private void OnDestroy()
		{
			_AlwaysBatch.Dispose();
			_ZTestBatch.Dispose();
		}

		private void Clear()
		{
			_drawTextEntries.Clear();
			_lineEntries.Clear();
			_linesNeedRebuild = true;
		}

		public void RegisterLine(Vector3 start, Vector3 end, Color color, float timer, bool noZTest)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			CheckInitialized();
			DrawLineEntry drawLineEntry = null;
			for (int i = 0; i < _lineEntries.Count; i++)
			{
				if (!_lineEntries[i].occupied)
				{
					drawLineEntry = _lineEntries[i];
					break;
				}
			}
			if (drawLineEntry == null)
			{
				drawLineEntry = new DrawLineEntry();
				_lineEntries.Add(drawLineEntry);
			}
			drawLineEntry.occupied = true;
			drawLineEntry.start = start;
			drawLineEntry.end = end;
			drawLineEntry.color = color;
			drawLineEntry.timer = timer;
			drawLineEntry.noZTest = noZTest;
			_linesNeedRebuild = true;
		}

		private void RebuildDrawLineBatchMesh()
		{
			//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_0069: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			_ZTestBatch.Clear();
			_AlwaysBatch.Clear();
			for (int i = 0; i < _lineEntries.Count; i++)
			{
				DrawLineEntry drawLineEntry = _lineEntries[i];
				if (drawLineEntry.occupied)
				{
					if (drawLineEntry.noZTest)
					{
						_AlwaysBatch.AddLine(drawLineEntry.start, drawLineEntry.end, drawLineEntry.color);
					}
					else
					{
						_ZTestBatch.AddLine(drawLineEntry.start, drawLineEntry.end, drawLineEntry.color);
					}
				}
			}
			_ZTestBatch.BuildBatch();
			_AlwaysBatch.BuildBatch();
		}

		private void TickAndDrawLines()
		{
			//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_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)
			if (_linesNeedRebuild)
			{
				RebuildDrawLineBatchMesh();
				_linesNeedRebuild = false;
			}
			Graphics.DrawMesh(_AlwaysBatch.mesh, Vector3.zero, Quaternion.identity, _AlwaysBatch.mat, 4, (Camera)null, 0, (MaterialPropertyBlock)null, false, false);
			Graphics.DrawMesh(_ZTestBatch.mesh, Vector3.zero, Quaternion.identity, _ZTestBatch.mat, 4, (Camera)null, 0, (MaterialPropertyBlock)null, false, false);
			for (int i = 0; i < _lineEntries.Count; i++)
			{
				DrawLineEntry drawLineEntry = _lineEntries[i];
				if (drawLineEntry.occupied)
				{
					drawLineEntry.timer -= Time.deltaTime;
					if (drawLineEntry.timer < 0f)
					{
						drawLineEntry.occupied = false;
						_linesNeedRebuild = true;
					}
				}
			}
		}

		public void RegisterDrawText(Vector3 anchor, string text, Color color, int size, float timer, bool popUp)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			CheckInitialized();
			DrawTextEntry drawTextEntry = null;
			for (int i = 0; i < _drawTextEntries.Count; i++)
			{
				if (!_drawTextEntries[i].occupied)
				{
					drawTextEntry = _drawTextEntries[i];
					break;
				}
			}
			if (drawTextEntry == null)
			{
				drawTextEntry = new DrawTextEntry();
				_drawTextEntries.Add(drawTextEntry);
			}
			drawTextEntry.occupied = true;
			drawTextEntry.anchor = anchor;
			drawTextEntry.content.text = text;
			drawTextEntry.size = size;
			drawTextEntry.color = color;
			drawTextEntry.duration = (drawTextEntry.timer = timer);
			drawTextEntry.popUp = popUp;
			drawTextEntry.flag = DrawFlag.DrawnGizmo;
		}

		public void RegisterAttachText(Transform target, Func<string> strFunc, Vector3 offset, Color color, int size)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			CheckInitialized();
			AttachTextEntry attachTextEntry = null;
			for (int i = 0; i < _attachTextEntries.Count; i++)
			{
				if (!_attachTextEntries[i].occupied)
				{
					attachTextEntry = _attachTextEntries[i];
					break;
				}
			}
			if (attachTextEntry == null)
			{
				attachTextEntry = new AttachTextEntry();
				_attachTextEntries.Add(attachTextEntry);
			}
			attachTextEntry.occupied = true;
			attachTextEntry.offset = offset;
			attachTextEntry.transform = target;
			attachTextEntry.strFunc = strFunc;
			attachTextEntry.color = color;
			attachTextEntry.size = size;
			attachTextEntry.content.text = strFunc();
			attachTextEntry.flag = DrawFlag.DrawnGizmo;
		}

		private void TickTexts()
		{
			for (int i = 0; i < _drawTextEntries.Count; i++)
			{
				DrawTextEntry drawTextEntry = _drawTextEntries[i];
				if (drawTextEntry.occupied)
				{
					drawTextEntry.timer -= Time.deltaTime;
					if (drawTextEntry.flag == DrawFlag.DrawnAll && drawTextEntry.timer < 0f)
					{
						drawTextEntry.occupied = false;
					}
				}
			}
			for (int j = 0; j < _attachTextEntries.Count; j++)
			{
				AttachTextEntry attachTextEntry = _attachTextEntries[j];
				if (attachTextEntry.occupied)
				{
					if ((Object)(object)attachTextEntry.transform == (Object)null)
					{
						attachTextEntry.occupied = false;
						attachTextEntry.strFunc = null;
					}
					else if (attachTextEntry.flag == DrawFlag.DrawnAll)
					{
						attachTextEntry.content.text = attachTextEntry.strFunc();
						attachTextEntry.flag = DrawFlag.DrawnGizmo;
					}
				}
			}
		}

		private void DrawTextOnGUI()
		{
			Camera debugDrawCamera = Draw.GetDebugDrawCamera();
			if ((Object)(object)debugDrawCamera == (Object)null)
			{
				return;
			}
			for (int i = 0; i < _drawTextEntries.Count; i++)
			{
				DrawTextEntry drawTextEntry = _drawTextEntries[i];
				if (drawTextEntry.occupied)
				{
					GUIDrawTextEntry(debugDrawCamera, drawTextEntry);
					drawTextEntry.flag |= DrawFlag.DrawnGUI;
				}
			}
			for (int j = 0; j < _attachTextEntries.Count; j++)
			{
				AttachTextEntry attachTextEntry = _attachTextEntries[j];
				if (attachTextEntry.occupied)
				{
					GUIAttachTextEntry(debugDrawCamera, attachTextEntry);
					attachTextEntry.flag |= DrawFlag.DrawnGUI;
				}
			}
		}

		private void GUIDrawTextEntry(Camera camera, DrawTextEntry entry)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			Vector3 anchor = entry.anchor;
			Vector3 val = camera.WorldToScreenPoint(anchor);
			val.y = (float)Screen.height - val.y;
			if (entry.popUp)
			{
				float num = entry.timer / entry.duration;
				val.y -= (1f - num * num) * (float)entry.size * 1.5f;
			}
			_textStyle.normal.textColor = entry.color;
			_textStyle.fontSize = entry.size;
			GUI.Label(new Rect(Vector2.op_Implicit(val), _textStyle.CalcSize(entry.content)), entry.content, _textStyle);
		}

		private void GUIAttachTextEntry(Camera camera, AttachTextEntry entry)
		{
			//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)
			//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_002d: 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_004e: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)entry.transform == (Object)null))
			{
				Vector3 val = entry.transform.position + entry.offset;
				Vector3 val2 = camera.WorldToScreenPoint(val);
				val2.y = (float)Screen.height - val2.y;
				_textStyle.normal.textColor = entry.color;
				_textStyle.fontSize = entry.size;
				GUI.Label(new Rect(Vector2.op_Implicit(val2), _textStyle.CalcSize(entry.content)), entry.content, _textStyle);
			}
		}
	}
}
namespace ValheimPerformanceOptimizations.Extensions
{
	public static class BoundsX
	{
		public static bool IntersectsXZ(this Bounds b1, Bounds b2)
		{
			//IL_0002: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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)
			if ((double)((Bounds)(ref b1)).min.x <= (double)((Bounds)(ref b2)).max.x && (double)((Bounds)(ref b1)).max.x >= (double)((Bounds)(ref b2)).min.x && (double)((Bounds)(ref b1)).min.z <= (double)((Bounds)(ref b2)).max.z)
			{
				return (double)((Bounds)(ref b1)).max.z >= (double)((Bounds)(ref b2)).min.z;
			}
			return false;
		}

		public static bool IntersectsSphere(this Bounds bounds, Vector3 center, float radius)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0086: 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_00b0: 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_000a: Unknown result type (might be due to invalid IL or missing references)
			if (radius == 0f)
			{
				return ((Bounds)(ref bounds)).Contains(center);
			}
			Vector3 val = ((Bounds)(ref bounds)).center - ((Bounds)(ref bounds)).extents;
			Vector3 val2 = ((Bounds)(ref bounds)).center + ((Bounds)(ref bounds)).extents;
			double num = Math.Max(val.x - center.x, 0f) + Math.Max(center.x - val2.x, 0f);
			double num2 = Math.Max(val.y - center.y, 0f) + Math.Max(center.y - val2.y, 0f);
			double num3 = Math.Max(val.z - center.z, 0f) + Math.Max(center.z - val2.z, 0f);
			if (num < (double)radius && num2 < (double)radius && num3 < (double)radius)
			{
				return num * num + num2 * num2 + num3 * num3 < (double)(radius * radius);
			}
			return false;
		}
	}
	public static class CollectionX
	{
	}
	public static class ListX
	{
		public static void RemoveAtSwapBack<T>(this List<T> list, int index)
		{
			int index2 = list.Count - 1;
			list[index] = list[index2];
			list.RemoveAt(index2);
		}

		public static void RemoveAtSwapBack<T, TKey>(this List<T> list, int index, Dictionary<TKey, int> indices, Func<T, TKey> keySelector)
		{
			int num = list.Count - 1;
			T arg = list[index];
			indices.Remove(keySelector(arg));
			if (index != num)
			{
				T arg2 = (list[index] = list[num]);
				indices[keySelector(arg2)] = index;
			}
			list.RemoveAt(num);
		}

		public static bool RemoveSwapBack<T>(this List<T> list, T item)
		{
			int num = list.IndexOf(item);
			if (num < 0)
			{
				return false;
			}
			list.RemoveAtSwapBack(num);
			return true;
		}
	}
	public static class NumberX
	{
		public static bool IsNearlyEqual(this float x, float y)
		{
			return Mathf.Approximately(x, y);
		}
	}
}
namespace ValheimPerformanceOptimizations.Patches
{
	internal static class BinarySearchDictionarySetValuePatch
	{
		private static readonly MethodInfo SetValuePrefixMethod;

		static BinarySearchDictionarySetValuePatch()
		{
			SetValuePrefixMethod = AccessTools.Method(typeof(BinarySearchDictionarySetValuePatch), "SetValuePrefix", (Type[])null, (Type[])null);
			ValheimPerformanceOptimizations.OnInitialized += Initialize;
		}

		private static void Initialize(ConfigFile _, Harmony harmony)
		{
			PatchSetValue<float>(harmony);
			PatchSetValue<Vector3>(harmony);
			PatchSetValue<Quaternion>(harmony);
			PatchSetValue<int>(harmony);
			PatchSetValue<long>(harmony);
			PatchSetValue<string>(harmony);
			PatchSetValue<byte[]>(harmony);
		}

		private static void PatchSetValue<TValue>(Harmony harmony)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(BinarySearchDictionary<int, TValue>), "SetValue", new Type[2]
			{
				typeof(int),
				typeof(TValue)
			}, (Type[])null);
			MethodInfo methodInfo2 = SetValuePrefixMethod.MakeGenericMethod(typeof(TValue));
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool SetValuePrefix<TValue>(BinarySearchDictionary<int, TValue> __instance, int key, TValue value, ref bool __result)
		{
			bool flag = default(bool);
			int num = __instance.BinaryFindKeyIndex(key, ref flag);
			if (flag)
			{
				if (EqualityComparer<TValue>.Default.Equals(__instance.m_values[num], value))
				{
					__result = false;
					return false;
				}
				__instance.m_values[num] = value;
				__result = true;
				return false;
			}
			__instance.GuaranteeCapacity();
			if (__instance.m_length - num > 0)
			{
				Array.Copy(__instance.m_keys, num, __instance.m_keys, num + 1, __instance.m_length - num);
				Array.Copy(__instance.m_values, num, __instance.m_values, num + 1, __instance.m_length - num);
			}
			__instance.m_keys[num] = key;
			__instance.m_values[num] = value;
			__instance.m_length++;
			__result = true;
			return false;
		}
	}
	internal static class CharacterTransformCachePatch
	{
		private static Character _cachedCharacter;

		private static Transform _cachedTransform;

		private static bool _cacheActive;

		private static IEnumerable<MethodBase> TargetMethods()
		{
			foreach (Type characterType in GetCharacterTypes())
			{
				if (!characterType.ContainsGenericParameters)
				{
					MethodInfo method = characterType.GetMethod("CustomFixedUpdate", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(float) }, null);
					if (method != null && !method.ContainsGenericParameters)
					{
						yield return method;
					}
				}
			}
		}

		[HarmonyPrefix]
		private static void Prefix(Character __instance, out bool __state)
		{
			__state = !_cacheActive;
			if (__state)
			{
				_cachedCharacter = __instance;
				_cachedTransform = ((Component)__instance).transform;
				_cacheActive = true;
			}
		}

		[HarmonyFinalizer]
		private static Exception Finalizer(Exception __exception, bool __state)
		{
			if (__state)
			{
				_cachedCharacter = null;
				_cachedTransform = null;
				_cacheActive = false;
			}
			return __exception;
		}

		internal static Transform GetCachedTransform(Character character)
		{
			if (!_cacheActive || _cachedCharacter != character)
			{
				return ((Component)character).transform;
			}
			return _cachedTransform;
		}

		private static IEnumerable<Type> GetCharacterTypes()
		{
			Assembly assembly = typeof(Character).Assembly;
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(assembly);
			foreach (Type type in typesFromAssembly)
			{
				if (type == typeof(Character) || type.IsSubclassOf(typeof(Character)))
				{
					yield return type;
				}
			}
		}
	}
	internal static class CharacterTransformCacheTranspiler
	{
		private static readonly MethodInfo TransformGetter = AccessTools.PropertyGetter(typeof(Component), "transform");

		private static readonly MethodInfo GetCachedTransformMethod = AccessTools.Method(typeof(CharacterTransformCachePatch), "GetCachedTransform", new Type[1] { typeof(Character) }, (Type[])null);

		private static IEnumerable<MethodBase> TargetMethods()
		{
			Assembly assembly = typeof(Character).Assembly;
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(assembly);
			foreach (Type type in typesFromAssembly)
			{
				if ((type != typeof(Character) && !type.IsSubclassOf(typeof(Character))) || type.ContainsGenericParameters)
				{
					continue;
				}
				foreach (MethodInfo declaredMethod in AccessTools.GetDeclaredMethods(type))
				{
					if (IsSupportedMethod(declaredMethod))
					{
						yield return declaredMethod;
					}
				}
			}
		}

		private static bool IsSupportedMethod(MethodBase method)
		{
			if (!method.IsStatic && !method.IsAbstract && !method.ContainsGenericParameters)
			{
				return method.GetMethodBody() != null;
			}
			return false;
		}

		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 1; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], TransformGetter) && !(list[i - 1].opcode != OpCodes.Ldarg_0))
				{
					list[i].opcode = OpCodes.Call;
					list[i].operand = GetCachedTransformMethod;
				}
			}
			return list;
		}
	}
	[HarmonyPatch]
	public class ClutterSystemRenderQueuePatch
	{
		[HarmonyPatch(typeof(ClutterSystem), "Awake")]
		private static void Postfix(ClutterSystem __instance)
		{
			foreach (Clutter item in __instance.m_clutter)
			{
				InstanceRenderer component = item.m_prefab.GetComponent<InstanceRenderer>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.m_material.renderQueue = 2450;
				}
			}
		}
	}
	[HarmonyPatch]
	public static class EffectCulling
	{
		private const float EffectCullDistance = 288f;

		[HarmonyPatch(typeof(GameCamera), "Awake")]
		[HarmonyPostfix]
		private static void GameCamera_Awake_Postfix(GameCamera __instance)
		{
			Camera camera = __instance.m_camera;
			if (Object.op_Implicit((Object)(object)camera))
			{
				float[] layerCullDistances = camera.layerCullDistances;
				layerCullDistances[LayerMask.NameToLayer("TransparentFX")] = 288f;
				layerCullDistances[LayerMask.NameToLayer("effect")] = 288f;
				camera.layerCullDistances = layerCullDistances;
				camera.layerCullSpherical = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class LocationZoneCachePatch
	{
		private static readonly Dictionary<Vector2s, Location> LocationByZone = new Dictionary<Vector2s, Location>();

		[HarmonyPatch(typeof(Location), "Awake")]
		[HarmonyPostfix]
		private static void Location_Awake_Postfix(Location __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			LocationByZone[ZoneSystem.GetZone(((Component)__instance).transform.position)] = __instance;
		}

		[HarmonyPatch(typeof(Location), "OnDestroy")]
		[HarmonyPrefix]
		private static void Location_OnDestroy_Prefix(Location __instance)
		{
			//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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Vector2s zone = ZoneSystem.GetZone(((Component)__instance).transform.position);
			LocationByZone.Remove(zone);
		}

		[HarmonyPatch(typeof(Location), "GetZoneLocation", new Type[] { typeof(Vector2s) })]
		[HarmonyPrefix]
		private static bool Location_GetZoneLocation_Prefix(Vector2s zone, ref Location __result)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			LocationByZone.TryGetValue(zone, out __result);
			return false;
		}

		[HarmonyPatch(typeof(Location), "GetZoneLocation", new Type[] { typeof(Vector3) })]
		[HarmonyPrefix]
		private static bool Location_GetZoneLocationByPosition_Prefix(Vector3 point, ref Location __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Vector2s zone = ZoneSystem.GetZone(point);
			LocationByZone.TryGetValue(zone, out __result);
			return false;
		}
	}
	public static class MaxPhysicsTimeStepPatch
	{
		private static ConfigEntry<int> _maxUpdatesPerFrame;

		static MaxPhysicsTimeStepPatch()
		{
			ValheimPerformanceOptimizations.OnInitialized += Initialize;
		}

		private static void Initialize(ConfigFile configFile, Harmony harmony)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription("The engine updates physics multiple times per frame. \nCoincidentally, physics calculation is the most expensive part of Valheim and it can be done up to 15 times per frame. \nIf can't get more than 20 fps, reducing this value can significantly boost fps in bases at the cost of less accurate physics. \nThe lowest you can go is 5", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 15), Array.Empty<object>());
			_maxUpdatesPerFrame = configFile.Bind<int>("General", "Max physics updates per frame", 8, val);
			harmony.PatchAll(typeof(MaxPhysicsTimeStepPatch));
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[HarmonyPostfix]
		private static void Postfix()
		{
			Time.maximumDeltaTime = (float)_maxUpdatesPerFrame.Value * Time.fixedDeltaTime;
		}
	}
	public static class PrefabMaterialCombiner
	{
		private const string AlphaTestOn = "_ALPHATEST_ON";

		public static void CombinePrefabMaterials(GameObject prefab)
		{
			WearNTear component = prefab.GetComponent<WearNTear>();
			LODGroup component2 = ((Component)component).GetComponent<LODGroup>();
			if ((Object)(object)component2 != (Object)null)
			{
				CombineTexturesForObject(CollectValidRenderers(component2));
				return;
			}
			List<Renderer> list = new List<Renderer>();
			GameObject worn = component.m_worn;
			if ((Object)(object)worn != (Object)null)
			{
				list.AddRange(CollectValidRenderers(worn.GetComponent<LODGroup>()));
			}
			GameObject val = component.m_new;
			if ((Object)(object)val != (Object)null)
			{
				list.AddRange(CollectValidRenderers(val.GetComponent<LODGroup>()));
			}
			GameObject wet = component.m_wet;
			if ((Object)(object)wet != (Object)null)
			{
				list.AddRange(CollectValidRenderers(wet.GetComponent<LODGroup>()));
			}
			GameObject val2 = component.m_new;
			if ((Object)(object)val2 != (Object)null)
			{
				list.AddRange(CollectValidRenderers(val2.GetComponent<LODGroup>()));
			}
			CombineTexturesForObject(list);
		}

		private static IEnumerable<Renderer> CollectValidRenderers(LODGroup inlineLodGroup)
		{
			return inlineLodGroup.GetLODs().SelectMany((LOD lod) => lod.renderers).Where(delegate(Renderer r)
			{
				Material[] sharedMaterials = r.sharedMaterials;
				return sharedMaterials.Length > 1 && (from mat in sharedMaterials
					group mat by mat.IsKeywordEnabled("_ALPHATEST_ON")).Any((IGrouping<bool, Material> group) => group.Count() > 1);
			});
		}

		private static void CombineTexturesForObject(IEnumerable<Renderer> renderers)
		{
			//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_0093: Expected O, but got Unknown
			//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: 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_0165: 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_01f5: 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_0209: 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)
			foreach (Renderer renderer in renderers)
			{
				MeshFilter component = ((Component)renderer).gameObject.GetComponent<MeshFilter>();
				Mesh sharedMesh = component.sharedMesh;
				List<Material> list = new List<Material>();
				List<Mesh> list2 = new List<Mesh>();
				IEnumerable<IGrouping<bool, Material>> enumerable = from mat in renderer.sharedMaterials
					group mat by mat.IsKeywordEnabled("_ALPHATEST_ON");
				int num = 0;
				foreach (IGrouping<bool, Material> item in enumerable)
				{
					List<Material> list3 = item.ToList();
					Texture2D val = new Texture2D(1024, 1024)
					{
						filterMode = (FilterMode)0
					};
					Texture2D[] array = list3.Select((Material m) => ConvertToReadableTexture(m.mainTexture)).ToArray();
					Rect[] array2 = val.PackTextures(array, 2, 1024);
					Texture2D val2 = new Texture2D(1024, 1024)
					{
						filterMode = (FilterMode)0
					};
					Texture2D[] array3 = list3.Select((Material m) => ConvertToReadableTexture(m.GetTexture("_BumpMap"))).ToArray();
					val2.PackTextures(array3, 2, 1024);
					Material val3 = list3[0];
					Material val4 = new Material(val3.shader);
					val4.CopyPropertiesFromMaterial(val3);
					val4.SetTexture("_MainTex", (Texture)(object)val);
					val4.SetTexture("_BumpMap", (Texture)(object)val2);
					val4.mainTextureScale = Vector2.one;
					if (val3.IsKeywordEnabled("_ALPHATEST_ON"))
					{
						val4.renderQueue = 2450;
						val4.EnableKeyword("_ALPHATEST_ON");
					}
					else
					{
						val4.SetOverrideTag("RenderType", "");
						val4.DisableKeyword("_ALPHATEST_ON");
					}
					list.Add(val4);
					Mesh[] array4 = (Mesh[])(object)new Mesh[list3.Count];
					for (int num2 = 0; num2 < list3.Count; num2++)
					{
						array4[num2] = ExtractMesh(sharedMesh, num2 + num);
						Vector2[] uv = array4[num2].uv;
						Rect bounds = array2[num2];
						for (int num3 = 0; num3 < uv.Length; num3++)
						{
							uv[num3] = RemapUVToBounds(uv[num3], bounds);
						}
						array4[num2].uv = uv;
					}
					num += list3.Count;
					list2.Add((array4.Length > 1) ? CombineMeshes(array4, mergeSubMeshes: true) : array4[0]);
				}
				Mesh mesh = CombineMeshes(list2.ToArray(), mergeSubMeshes: false);
				component.mesh = mesh;
				renderer.materials = list.ToArray();
			}
		}

		private static Texture2D ConvertToReadableTexture(Texture source)
		{
			//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_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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			RenderTexture temporary = RenderTexture.GetTemporary(source.width, source.height, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)2);
			Graphics.Blit(source, temporary);
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary;
			Texture2D val = new Texture2D(source.width, source.height);
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
			((Texture)val).filterMode = (FilterMode)0;
			val.Apply();
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
			return val;
		}

		private static Mesh ExtractMesh(Mesh masterMesh, int subMeshIndex)
		{
			//IL_0076: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			int[] indices = masterMesh.GetIndices(subMeshIndex);
			int num = 0;
			int[] array = indices;
			foreach (int key in array)
			{
				if (!dictionary.ContainsKey(key))
				{
					dictionary.Add(key, num);
					num++;
				}
			}
			List<Vector3> list = new List<Vector3>();
			List<Vector2> list2 = new List<Vector2>();
			List<Vector3> list3 = new List<Vector3>();
			foreach (KeyValuePair<int, int> item in dictionary)
			{
				list.Add(masterMesh.vertices[item.Key]);
				list2.Add(masterMesh.uv[item.Key]);
				list3.Add(masterMesh.normals[item.Key]);
			}
			int[] triangles = masterMesh.GetTriangles(subMeshIndex);
			int[] array2 = new int[triangles.Length];
			for (int j = 0; j < triangles.Length; j++)
			{
				array2[j] = dictionary[triangles[j]];
			}
			return new Mesh
			{
				vertices = list.ToArray(),
				uv = list2.ToArray(),
				normals = list3.ToArray(),
				triangles = array2
			};
		}

		private static Vector2 RemapUVToBounds(Vector2 oldUV, Rect bounds)
		{
			//IL_0010: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			oldUV.x = Mathf.Lerp(((Rect)(ref bounds)).xMin, ((Rect)(ref bounds)).xMax, oldUV.x);
			oldUV.y = Mathf.Lerp(((Rect)(ref bounds)).yMin, ((Rect)(ref bounds)).yMax, oldUV.y);
			return oldUV;
		}

		private static Mesh CombineMeshes(Mesh[] meshes, bool mergeSubMeshes)
		{
			//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_0035: Expected O, but got Unknown
			CombineInstance[] array = (CombineInstance[])(object)new CombineInstance[meshes.Length];
			for (int i = 0; i < array.Length; i++)
			{
				((CombineInstance)(ref array[i])).mesh = meshes[i];
			}
			Mesh val = new Mesh();
			val.CombineMeshes(array, mergeSubMeshes, false);
			return val;
		}
	}
	[HarmonyPatch]
	public static class PrefabPatches
	{
		private const float LeafParticleCullHeight = 0.79f;

		private static readonly List<string> PrefabsWithLeafParticles = new List<string>();

		private static readonly List<string> MaterialsWithDisabledInstancing = new List<string> { "Grill_mat", "meadbase", "poison", "poisonres_potion", "stamina_potion", "portal_small" }.Select((string material) => material + " (Instance)").ToList();

		private static readonly List<string> PrefabsWithDisabledInstancing = new List<string>
		{
			"piece_cookingstation", "MeadBaseFrostResist", "MeadBaseHealthMedium", "MeadBaseHealthMinor", "MeadBasePoisonResist", "MeadBaseStaminaMedium", "MeadBaseStaminaMinor", "MeadBaseTasty", "MeadPoisonResist", "MeadStaminaMedium",
			"MeadStaminaMinor", "portal_wood"
		};

		private static readonly List<string> PrefabsWithWastedMaterials = new List<string>();

		private static bool _isPatched;

		private static void PatchPrefabWithLeaves(GameObject prefab)
		{
			//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_0047: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystemRenderer component = ((Component)((Component)Utils.FindChild(prefab.transform, "leaf_particles", (IterativeSearchType)0)).GetComponent<ParticleSystem>()).GetComponent<ParticleSystemRenderer>();
			component.renderMode = (ParticleSystemRenderMode)4;
			component.enableGPUInstancing = true;
			LODGroup component2 = prefab.GetComponent<LODGroup>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				LOD[] lODs = component2.GetLODs();
				LOD val = lODs[0];
				float screenRelativeTransitionHeight = val.screenRelativeTransitionHeight;
				val.screenRelativeTransitionHeight = 0.79f;
				Renderer[] array = val.renderers.Where((Renderer r) => ((Object)r).name != "leaf_particles").ToArray();
				LOD[] array2 = (LOD[])(object)new LOD[lODs.Length + 1];
				array2[0] = val;
				array2[1] = new LOD(screenRelativeTransitionHeight, array);
				for (int num = 1; num < lODs.Length; num++)
				{
					array2[num + 1] = lODs[num];
				}
				component2.SetLODs(array2);
			}
		}

		private static void PatchPrefabWithUninstancedMaterials(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Material[] sharedMaterials = componentsInChildren[i].sharedMaterials;
				foreach (Material val in sharedMaterials)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.enableInstancing = true;
					}
				}
			}
		}

		private static void PatchPrefabWithWastedMaterials(GameObject prefab)
		{
			PrefabMaterialCombiner.CombinePrefabMaterials(prefab);
		}

		private static int PatchLocalParticleSystemCulling(GameObject prefab)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			int num = LayerMask.NameToLayer("effect");
			int num2 = 0;
			ParticleSystem[] componentsInChildren = prefab.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem obj in componentsInChildren)
			{
				GameObject gameObject = ((Component)obj).gameObject;
				MainModule main = obj.main;
				ParticleSystemCullingMode? val = ((Object)gameObject).name switch
				{
					"flare" => (ParticleSystemCullingMode)2, 
					"flames" => (ParticleSystemCullingMode)1, 
					"flames (1)" => (ParticleSystemCullingMode)1, 
					"embers" => (ParticleSystemCullingMode)1, 
					"low_flames" => (ParticleSystemCullingMode)1, 
					"sparcs (1)" => (ParticleSystemCullingMode)1, 
					"smoke (1)" => (ParticleSystemCullingMode)1, 
					_ => null, 
				};
				if (val.HasValue)
				{
					((MainModule)(ref main)).cullingMode = val.Value;
				}
				if (val.HasValue || (!Object.op_Implicit((Object)(object)gameObject.GetComponent<Collider>()) && !Object.op_Implicit((Object)(object)gameObject.GetComponent<Rigidbody>())))
				{
					if (gameObject.layer != num)
					{
						gameObject.layer = LayerMask.NameToLayer("TransparentFX");
					}
					num2++;
				}
			}
			return num2;
		}

		private static string GetPrefabParticlePath(Transform particleTransform)
		{
			string text = ((Object)particleTransform).name;
			Transform val = particleTransform;
			while ((Object)(object)val.parent != (Object)null)
			{
				val = val.parent;
				text = ((Object)val).name + "/" + text;
			}
			return text;
		}

		private static void PatchSnowStormParticle()
		{
			//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_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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			GameObject obj = GameObject.Find("_GameMain/_Environment");
			Shader.Find("Lux Lit Particles/ Bumped");
			GameObject gameObject = ((Component)Utils.FindChild(obj.transform, "SnowStorm", (IterativeSearchType)0).GetChild(1)).gameObject;
			ParticleSystem component = gameObject.GetComponent<ParticleSystem>();
			MainModule main = component.main;
			((MainModule)(ref main)).maxParticles = 9000;
			MinMaxCurve startSize = ((MainModule)(ref main)).startSize;
			((MinMaxCurve)(ref startSize)).mode = (ParticleSystemCurveMode)3;
			((MinMaxCurve)(ref startSize)).constantMin = 0.03f;
			((MinMaxCurve)(ref startSize)).constantMax = 0.07f;
			((MainModule)(ref main)).startSize = startSize;
			EmissionModule emission = component.emission;
			MinMaxCurve rateOverTime = ((EmissionModule)(ref emission)).rateOverTime;
			((MinMaxCurve)(ref rateOverTime)).constant = 3000f;
			((EmissionModule)(ref emission)).rateOverTime = rateOverTime;
			ShapeModule shape = component.shape;
			((ShapeModule)(ref shape)).radiusThickness = 1f;
			Material material = ((Renderer)gameObject.GetComponent<ParticleSystemRenderer>()).material;
			material.mainTexture = null;
			material.DisableKeyword("GEOM_TYPE_FROND");
		}

		private static int PatchPrefabs(this IReadOnlyDictionary<int, GameObject> allPrefabs, IEnumerable<string> prefabNames, Action<GameObject> patcher)
		{
			int num = 0;
			foreach (string prefabName in prefabNames)
			{
				if (allPrefabs.TryGetValue(StringExtensionMethods.GetStableHashCode(prefabName), out var value))
				{
					patcher(value);
					num++;
				}
			}
			return num;
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static void Postfix(ZNetScene __instance, Dictionary<int, GameObject> ___m_namedPrefabs)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Invalid comparison between Unknown and I4
			if (_isPatched)
			{
				return;
			}
			Dictionary<int, GameObject> namedPrefabs = __instance.m_namedPrefabs;
			int num = 0;
			int num2 = 0;
			num += namedPrefabs.PatchPrefabs(PrefabsWithLeafParticles, PatchPrefabWithLeaves);
			foreach (GameObject value in namedPrefabs.Values)
			{
				PatchPrefabWithUninstancedMaterials(value);
				num2 += PatchLocalParticleSystemCulling(value);
				num++;
			}
			if ((int)SystemInfo.graphicsDeviceType != 4)
			{
				DateTime now = DateTime.Now;
				num += namedPrefabs.PatchPrefabs(PrefabsWithWastedMaterials, PatchPrefabWithWastedMaterials);
				ValheimPerformanceOptimizations.Logger.LogInfo((object)("Combined prefab mats in " + (DateTime.Now - now).TotalMilliseconds + " ms"));
			}
			num++;
			ValheimPerformanceOptimizations.Logger.LogInfo((object)$"Updated culling for {num2} local-space flare or flame particle systems");
			ValheimPerformanceOptimizations.Logger.LogInfo((object)$"Patched {num} prefabs");
			_isPatched = true;
		}
	}
	public static class ReuseCollisionCallbacksPatch
	{
		private static ConfigEntry<bool> _reuseCollisionCallbacks;

		static ReuseCollisionCallbacksPatch()
		{
			ValheimPerformanceOptimizations.OnInitialized += Initialize;
		}

		private static void Initialize(ConfigFile configFile, Harmony harmony)
		{
			_reuseCollisionCallbacks = configFile.Bind<bool>("General", "Reuse collision callbacks", true, "Significantly reduces GC in physics-heavy scenes. Disable if there are collision issues in mod-heavy scenarios.");
			_reuseCollisionCallbacks.SettingChanged += delegate
			{
				Apply();
			};
			Apply();
		}

		private static void Apply()
		{
			Physics.reuseCollisionCallbacks = _reuseCollisionCallbacks.Value;
		}
	}
	public class VPOTerrainLodShadowRenderer : MonoBehaviour
	{
		public const int TerrainLodLayer = 30;

		public static VPOTerrainLodShadowRenderer Instance;

		private Light directionalLight;

		private Heightmap heightmap;

		private int shadowCascadeCount = -1;

		private int shadowCasterPass = -1;

		private CommandBuffer shadowPassCommandBuffer;

		private Matrix4x4 terrainTransform;

		private void Awake()
		{
			//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_001c: Expected O, but got Unknown
			Instance = this;
			shadowPassCommandBuffer = new CommandBuffer
			{
				name = "Last cascade terrain pass"
			};
			directionalLight = ((Component)this).GetComponent<Light>();
			Transform val = GameObject.Find("_GameMain").transform.Find("Terrain_lod");
			((Component)val).gameObject.layer = 30;
			heightmap = ((Component)val).GetComponent<Heightmap>();
		}

		public void HeightmapChanged()
		{
			ValheimPerformanceOptimizations.Logger.LogInfo((object)"HEIGHTMAP CHANGED");
			UpdateCommandBuffer();
			SetShadowCascadeCount(QualitySettings.shadowCascades);
		}

		public void SetShadowCascadeCount(int cascadeCount)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (shadowCascadeCount != cascadeCount)
			{
				shadowCascadeCount = QualitySettings.shadowCascades;
				directionalLight.RemoveCommandBuffer((LightEvent)4, shadowPassCommandBuffer);
				directionalLight.AddCommandBuffer((LightEvent)4, shadowPassCommandBuffer, GetShadowMapPass(shadowCascadeCount));
			}
		}

		private void UpdateCommandBuffer()
		{
			//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_003f: Unknown result type (m