using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoMod.Cil;
using MonoMod.Utils;
using SoftReferenceableAssets;
using UnityEngine;
using Valheim.ServersideQoL.HarmonyPatches;
using Valheim.ServersideQoL.Processors;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.TypeInspectors;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Valheim.ServersideQoL")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.2.0")]
[assembly: AssemblyInformationalVersion("1.2.2-beta.0.13+13856f8ec28527afde6aa1afc782e1986d8f1f8b")]
[assembly: AssemblyProduct("Valheim.ServersideQoL")]
[assembly: AssemblyTitle("Valheim.ServersideQoL")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Valheim.ServersideQoL
{
	internal sealed class ConcurrentHashSet<T> : ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T> where T : notnull
	{
		private readonly ConcurrentDictionary<T, object?> _dict = new ConcurrentDictionary<T, object>();

		public int Count => _dict.Count;

		bool ICollection<T>.IsReadOnly => false;

		public bool Add(T value)
		{
			return _dict.TryAdd(value, null);
		}

		public bool Remove(T value)
		{
			object value2;
			return _dict.TryRemove(value, out value2);
		}

		void ICollection<T>.Add(T item)
		{
			if (!Add(item))
			{
				throw new InvalidOperationException();
			}
		}

		public void Clear()
		{
			_dict.Clear();
		}

		public bool Contains(T item)
		{
			return _dict.ContainsKey(item);
		}

		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			throw new NotImplementedException();
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			return _dict.Keys.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _dict.Keys.GetEnumerator();
		}
	}
	internal static class EnumUtils
	{
		private static class Generic<T> where T : unmanaged, Enum
		{
			public static bool IsBitSet { get; } = OfType(typeof(T)).IsBitSet;


			public static Func<T, ulong> EnumToUInt64 { get; }

			public static Func<ulong, T> UInt64ToEnum { get; }

			public static Func<T, long> EnumToInt64 { get; }

			public static Func<long, T> Int64ToEnum { get; }

			static Generic()
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(T));
				EnumToUInt64 = Expression.Lambda<Func<T, ulong>>(Expression.ConvertChecked(parameterExpression, typeof(ulong)), new ParameterExpression[1] { parameterExpression }).Compile();
				ParameterExpression parameterExpression2 = Expression.Parameter(typeof(ulong));
				UInt64ToEnum = Expression.Lambda<Func<ulong, T>>(Expression.ConvertChecked(parameterExpression2, typeof(T)), new ParameterExpression[1] { parameterExpression2 }).Compile();
				ParameterExpression parameterExpression3 = Expression.Parameter(typeof(T));
				EnumToInt64 = Expression.Lambda<Func<T, long>>(Expression.ConvertChecked(parameterExpression3, typeof(long)), new ParameterExpression[1] { parameterExpression3 }).Compile();
				ParameterExpression parameterExpression4 = Expression.Parameter(typeof(long));
				Int64ToEnum = Expression.Lambda<Func<long, T>>(Expression.ConvertChecked(parameterExpression4, typeof(T)), new ParameterExpression[1] { parameterExpression4 }).Compile();
			}
		}

		public sealed class ObjectEnumUtils
		{
			public bool IsBitSet { get; } = enumType.GetCustomAttribute<FlagsAttribute>() != null;


			public Func<object, ulong> EnumToUInt64 { get; }

			public Func<ulong, object> UInt64ToEnum { get; }

			public Func<object, long> EnumToInt64 { get; }

			public Func<long, object> Int64ToEnum { get; }

			public ObjectEnumUtils(Type enumType)
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(object));
				EnumToUInt64 = Expression.Lambda<Func<object, ulong>>(Expression.ConvertChecked(Expression.Convert(parameterExpression, enumType), typeof(ulong)), new ParameterExpression[1] { parameterExpression }).Compile();
				ParameterExpression parameterExpression2 = Expression.Parameter(typeof(ulong));
				UInt64ToEnum = Expression.Lambda<Func<ulong, object>>(Expression.Convert(Expression.ConvertChecked(parameterExpression2, enumType), typeof(object)), new ParameterExpression[1] { parameterExpression2 }).Compile();
				ParameterExpression parameterExpression3 = Expression.Parameter(typeof(object));
				EnumToInt64 = Expression.Lambda<Func<object, long>>(Expression.ConvertChecked(Expression.Convert(parameterExpression3, enumType), typeof(long)), new ParameterExpression[1] { parameterExpression3 }).Compile();
				ParameterExpression parameterExpression4 = Expression.Parameter(typeof(long));
				Int64ToEnum = Expression.Lambda<Func<long, object>>(Expression.Convert(Expression.ConvertChecked(parameterExpression4, enumType), typeof(object)), new ParameterExpression[1] { parameterExpression4 }).Compile();
				base..ctor();
			}
		}

		private static readonly ConcurrentDictionary<Type, ObjectEnumUtils> __isBitSet = new ConcurrentDictionary<Type, ObjectEnumUtils>();

		public static ObjectEnumUtils OfType(Type type)
		{
			return __isBitSet.GetOrAdd(type, (Type t) => new ObjectEnumUtils(t));
		}

		public static bool IsBitSet<T>() where T : unmanaged, Enum
		{
			return Generic<T>.IsBitSet;
		}

		public static ulong ToUInt64<T>(this T value) where T : unmanaged, Enum
		{
			return Generic<T>.EnumToUInt64(value);
		}

		public static T ToEnum<T>(ulong value) where T : unmanaged, Enum
		{
			return Generic<T>.UInt64ToEnum(value);
		}

		public static long ToInt64<T>(this T value) where T : unmanaged, Enum
		{
			return Generic<T>.EnumToInt64(value);
		}

		public static T ToEnum<T>(long value) where T : unmanaged, Enum
		{
			return Generic<T>.Int64ToEnum(value);
		}

		public static bool ExactlyOneBitSet<T>(this T value) where T : unmanaged, Enum
		{
			bool flag = false;
			for (ulong num = value.ToUInt64(); num != 0L; num &= num - 1)
			{
				if (flag)
				{
					return false;
				}
				flag = true;
			}
			return flag;
		}
	}
	internal interface IZDOInventoryReadOnly
	{
		IReadOnlyList<ItemData> Items { get; }
	}
	internal interface IZDOInventory
	{
		Inventory Inventory { get; }

		IList<ItemData> Items { get; }

		int? PickupRange { get; set; }

		int? FeedRange { get; set; }

		void Save();
	}
	internal sealed class ExtendedZDO : ZDO
	{
		public delegate void RecreateHandler(ExtendedZDO oldZdo, ExtendedZDO newZdo);

		public readonly struct ZDOVars_
		{
			private readonly ExtendedZDO _zdo;

			private static int __intTag = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.IntTag");

			private static int __lastSpawnedTime = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.LastSpawnedTime");

			private static int __spawnedByTrophy = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.SpawnedByTrophy");

			private static int __portalHubId = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.PortalHubId");

			private static int __returnContentToCreator = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.ReturnContentToCreator");

			private static int __initialLevel = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.PortalHubId");

			public ZDOVars_(ExtendedZDO zdo)
			{
				_zdo = zdo;
			}

			private void ValidateOwnership(string filePath, int lineNo)
			{
				if (Main.Instance.Config.General.DiagnosticLogs.Value && _zdo.PrefabInfo.Container.HasValue && !_zdo.IsOwnerOrUnassigned() && !_zdo.IsModCreator())
				{
					Main.Instance.Logger.LogWarning((object)$"{Path.GetFileName(filePath)} L{lineNo}: Container was modified while it is owned by a client, which can lead to the loss of items.");
				}
			}

			public int GetState(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_state, defaultValue);
			}

			public void SetState(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_state, value, false);
			}

			public long GetCreator(long defaultValue = 0L)
			{
				return ((ZDO)_zdo).GetLong(ZDOVars.s_creator, defaultValue);
			}

			public void SetCreator(long value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_creator, value);
			}

			public bool GetInUse(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_inUse, defaultValue);
			}

			public void SetInUse(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_inUse, value);
			}

			public float GetFuel(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_fuel, defaultValue);
			}

			public void SetFuel(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_fuel, value);
			}

			public bool GetPiece(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_piece, defaultValue);
			}

			public void SetPiece(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_piece, value);
			}

			public string GetItems(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_items, defaultValue);
			}

			public void SetItems(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_items, value);
			}

			public string GetTag(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_tag, defaultValue);
			}

			public void SetTag(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tag, value);
			}

			public byte[]? GetData(byte[]? defaultValue = null)
			{
				return ((ZDO)_zdo).GetByteArray(ZDOVars.s_data, defaultValue);
			}

			public void SetData(byte[]? value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_data, value);
			}

			public float GetStamina(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_stamina, defaultValue);
			}

			public void SetStamina(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_stamina, value);
			}

			public long GetPlayerID(long defaultValue = 0L)
			{
				return ((ZDO)_zdo).GetLong(ZDOVars.s_playerID, defaultValue);
			}

			public void SetPlayerID(long value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_playerID, value);
			}

			public string GetPlayerName(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_playerName, defaultValue);
			}

			public void SetPlayerName(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_playerName, value);
			}

			public string GetFollow(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_follow, defaultValue);
			}

			public void SetFollow(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_follow, value);
			}

			public int GetRightItem(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_rightItem, defaultValue);
			}

			public void SetRightItem(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_rightItem, value, false);
			}

			public string GetText(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_text, defaultValue);
			}

			public void SetText(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_text, value);
			}

			public string GetItem(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_item, defaultValue);
			}

			public void SetItem(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_item, value);
			}

			public string GetItem(int idx, string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(FormattableString.Invariant($"item{idx}"), defaultValue);
			}

			public void SetItem(int idx, string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(FormattableString.Invariant($"item{idx}"), value);
			}

			public int GetQueued(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_queued, defaultValue);
			}

			public void SetQueued(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_queued, value, false);
			}

			public bool GetTamed(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_tamed, defaultValue);
			}

			public void SetTamed(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tamed, value);
			}

			public float GetTameTimeLeft(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_tameTimeLeft, defaultValue);
			}

			public void SetTameTimeLeft(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tameTimeLeft, value);
			}

			public int GetAmmo(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_ammo, defaultValue);
			}

			public void SetAmmo(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_ammo, value, false);
			}

			public string GetAmmoType(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_ammoType, defaultValue);
			}

			public void SetAmmoType(string value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_ammoType, value);
			}

			public float GetGrowStart(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_growStart, defaultValue);
			}

			public void SetGrowStart(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_growStart, value);
			}

			public DateTime GetSpawnTime(DateTime defaultValue = default(DateTime))
			{
				return new DateTime(((ZDO)_zdo).GetLong(ZDOVars.s_spawnTime, defaultValue.Ticks));
			}

			public void SetSpawnTime(DateTime value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_spawnTime, value.Ticks);
			}

			public float GetHealth(float defaultValue = 0f)
			{
				return ((ZDO)_zdo).GetFloat(ZDOVars.s_health, defaultValue);
			}

			public void SetHealth(float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_health, value);
			}

			public void RemoveHealth([CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).RemoveFloat(ZDOVars.s_health);
			}

			public int GetPermitted(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_permitted, defaultValue);
			}

			public void SetPermitted(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_permitted, value, false);
			}

			public int GetLevel(int defaultValue = 1)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_level, defaultValue);
			}

			public void SetLevel(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_level, value, false);
			}

			public bool GetPatrol(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_patrol, defaultValue);
			}

			public void SetPatrol(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_patrol, value);
			}

			public Vector3 GetPatrolPoint(Vector3 defaultValue = default(Vector3))
			{
				//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)
				return ((ZDO)_zdo).GetVec3(ZDOVars.s_patrolPoint, defaultValue);
			}

			public void SetPatrolPoint(Vector3 value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_patrolPoint, value);
			}

			public Vector3 GetSpawnPoint(Vector3 defaultValue = default(Vector3))
			{
				//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)
				return ((ZDO)_zdo).GetVec3(ZDOVars.s_spawnPoint, defaultValue);
			}

			public void SetSpawnPoint(Vector3 value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_spawnPoint, value);
			}

			public int GetEmoteID(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_emoteID, defaultValue);
			}

			public Emotes GetEmote(Emotes defaultValue = -1)
			{
				//IL_0021: 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)
				if (!Enum.TryParse<Emotes>(((ZDO)_zdo).GetString(ZDOVars.s_emote, ""), ignoreCase: true, out Emotes result))
				{
					return defaultValue;
				}
				return result;
			}

			public bool GetAnimationIsEncumbered(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(PrivateAccessor.ZSyncAnimationZDOSalt + PrivateAccessor.CharacterAnimationHashEncumbered, defaultValue);
			}

			public bool GetAnimationInWater(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(PrivateAccessor.ZSyncAnimationZDOSalt + PrivateAccessor.CharacterAnimationHashInWater, defaultValue);
			}

			public bool GetAnimationIsCrouching(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(PrivateAccessor.ZSyncAnimationZDOSalt + PrivateAccessor.PlayerAnimationHashCrouching, defaultValue);
			}

			public DateTime GetTameLastFeeding(DateTime defaultValue = default(DateTime))
			{
				return new DateTime(((ZDO)_zdo).GetLong(ZDOVars.s_tameLastFeeding, defaultValue.Ticks));
			}

			public void SetTameLastFeeding(DateTime value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(ZDOVars.s_tameLastFeeding, value.Ticks);
			}

			public bool GetEventCreature(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_eventCreature, defaultValue);
			}

			public bool GetInBed(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(ZDOVars.s_inBed, defaultValue);
			}

			public int GetIntTag(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(__intTag, defaultValue);
			}

			public void SetIntTag(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__intTag, value, false);
			}

			public void RemoveIntTag([CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).RemoveInt(__intTag);
			}

			public DateTimeOffset GetLastSpawnedTime(DateTimeOffset defaultValue = default(DateTimeOffset))
			{
				return new DateTimeOffset(((ZDO)_zdo).GetLong(__lastSpawnedTime, defaultValue.Ticks), default(TimeSpan));
			}

			public void SetLastSpawnedTime(DateTimeOffset value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__lastSpawnedTime, value.Ticks - value.Offset.Ticks);
			}

			public bool GetSpawnedByTrophy(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(__spawnedByTrophy, defaultValue);
			}

			public void SetSpawnedByTrophy(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__spawnedByTrophy, value);
			}

			public int GetPortalHubId(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(__portalHubId, defaultValue);
			}

			public void SetPortalHubId(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__portalHubId, value, false);
			}

			public bool GetReturnContentToCreator(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(__returnContentToCreator, defaultValue);
			}

			public void SetReturnContentToCreator(bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__returnContentToCreator, value);
			}

			public int GetInitialLevel(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(__initialLevel, defaultValue);
			}

			public void SetInitialLevel(int value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__initialLevel, value, false);
			}

			public void RemoveInitialLevel([CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).RemoveInt(__initialLevel);
			}

			public bool GetSacrifiedMegingjord(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedMegingjord", defaultValue);
			}

			public void SetSacrifiedMegingjord(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedMegingjord", value);
			}

			public bool GetSacrifiedCryptKey(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedCryptKey", defaultValue);
			}

			public void SetSacrifiedCryptKey(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedCryptKey", value);
			}

			public bool GetSacrifiedWishbone(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedWishbone", defaultValue);
			}

			public void SetSacrifiedWishbone(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedWishbone", value);
			}

			public bool GetSacrifiedTornSpirit(long playerID, bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool($"player{playerID}_SacrifiedTornSpirit", defaultValue);
			}

			public void SetSacrifiedTornSpirit(long playerID, bool value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_SacrifiedTornSpirit", value);
			}
		}

		private sealed class AdditionalData_
		{
			private static ConcurrentDictionary<int, IReadOnlyList<Processor>> _processors = new ConcurrentDictionary<int, IReadOnlyList<Processor>>();

			public IReadOnlyList<Processor> Processors { get; private set; } = Processor.DefaultProcessors;


			public PrefabInfo PrefabInfo { get; }

			public ConcurrentDictionary<Type, object>? ComponentFieldAccessors { get; set; }

			public Dictionary<Processor, (uint Data, uint Owner)>? ProcessorDataRevisions { get; set; }

			public ZDOInventory? Inventory { get; set; }

			public bool? HasFields { get; set; }

			public RecreateHandler? Recreated { get; set; }

			public Action<ExtendedZDO>? Destroyed { get; set; }

			public static AdditionalData_ Dummy { get; } = new AdditionalData_(Valheim.ServersideQoL.PrefabInfo.Dummy);


			public AdditionalData_(PrefabInfo prefabInfo)
			{
				PrefabInfo = prefabInfo;
				base..ctor();
			}

			public void Ungregister(IEnumerable<Processor> processors)
			{
				IEnumerable<Processor> processors2 = processors;
				int num = 0;
				foreach (Processor processor in Processors)
				{
					if (!processors2.Any((Processor x) => x == processor))
					{
						num = (num, processor.GetType()).GetHashCode();
					}
				}
				Processors = _processors.GetOrAdd(num, (int _) => Processors.Where((Processor x) => !processors2.Any((Processor y) => x == y)).ToList());
				foreach (Processor item in processors2)
				{
					ProcessorDataRevisions?.Remove(item);
				}
			}

			public void UnregisterAll()
			{
				Processors = Array.Empty<Processor>();
			}

			public void ReregisterAll()
			{
				Processors = Processor.DefaultProcessors;
			}
		}

		public sealed class ComponentFieldAccessor<TComponent>
		{
			private readonly ExtendedZDO _zdo;

			private readonly TComponent _component;

			private bool? _hasComponentFields;

			private static readonly int __hasComponentFieldsHash = StringExtensionMethods.GetStableHashCode(FormattableString.Invariant(FormattableStringFactory.Create("{0}{1}", "HasFields", typeof(TComponent).Name)));

			public bool HasFields
			{
				get
				{
					if (_zdo.HasFields)
					{
						bool valueOrDefault = _hasComponentFields.GetValueOrDefault();
						if (!_hasComponentFields.HasValue)
						{
							valueOrDefault = ((ZDO)_zdo).GetBool(__hasComponentFieldsHash, false);
							_hasComponentFields = valueOrDefault;
							return valueOrDefault;
						}
						return valueOrDefault;
					}
					return false;
				}
			}

			public ComponentFieldAccessor(ExtendedZDO zdo, TComponent component)
			{
				_zdo = zdo;
				_component = component;
				base..ctor();
			}

			private void SetHasFields(bool value)
			{
				if (value && !_zdo.HasFields)
				{
					_zdo.SetHasFields();
				}
				if (_hasComponentFields != value)
				{
					ExtendedZDO zdo = _zdo;
					int _hasComponentFieldsHash = __hasComponentFieldsHash;
					bool? flag = (_hasComponentFields = value);
					((ZDO)zdo).Set(_hasComponentFieldsHash, flag.Value);
				}
			}

			private static int GetHash<T>(Expression<Func<TComponent, T>> fieldExpression, out FieldInfo field)
			{
				MemberExpression memberExpression = (MemberExpression)fieldExpression.Body;
				field = (FieldInfo)memberExpression.Member;
				return StringExtensionMethods.GetStableHashCode(FormattableString.Invariant($"{typeof(TComponent).Name}.{field.Name}"));
			}

			private T Get<T>(Expression<Func<TComponent, T>> fieldExpression, Func<ZDO, int, T?, T> getter)
			{
				FieldInfo fieldInfo = (FieldInfo)((MemberExpression)fieldExpression.Body).Member;
				if (!HasFields)
				{
					return (T)fieldInfo.GetValue(_component);
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(FormattableString.Invariant($"{typeof(TComponent).Name}.{fieldInfo.Name}"));
				return getter((ZDO)(object)_zdo, stableHashCode, (T)fieldInfo.GetValue(_component));
			}

			public bool GetBool(Expression<Func<TComponent, bool>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, bool defaultValue) => zdo.GetBool(hash, defaultValue));
			}

			public float GetFloat(Expression<Func<TComponent, float>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, float defaultValue) => zdo.GetFloat(hash, defaultValue));
			}

			public int GetInt(Expression<Func<TComponent, int>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, int defaultValue) => zdo.GetInt(hash, defaultValue));
			}

			public string GetString(Expression<Func<TComponent, string>> fieldExpression)
			{
				return Get(fieldExpression, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue));
			}

			private ComponentFieldAccessor<TComponent> SetCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, TObj valueObj, Action<ZDO, int>? remover, Action<ZDO, int, T> setter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T arg = cast(valueObj);
				if (remover != null)
				{
					ref T reference = ref arg;
					T val = default(T);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					if (reference.Equals(cast((TObj)field.GetValue(_component))))
					{
						remover((ZDO)(object)_zdo, hash);
						goto IL_008b;
					}
				}
				if (!HasFields)
				{
					SetHasFields(value: true);
				}
				setter((ZDO)(object)_zdo, hash, arg);
				goto IL_008b;
				IL_008b:
				return this;
			}

			private ComponentFieldAccessor<TComponent> SetCore<T>(Expression<Func<TComponent, T>> fieldExpression, T value, Action<ZDO, int>? remover, Action<ZDO, int, T> setter) where T : notnull
			{
				return SetCore(fieldExpression, value, remover, setter, (T x) => x);
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, bool>> fieldExpression, bool value)
			{
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, bool value)
				{
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, float>> fieldExpression, float value)
			{
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveFloat(hash);
				}, delegate(ZDO zdo, int hash, float value)
				{
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, int>> fieldExpression, int value)
			{
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, int value)
				{
					zdo.Set(hash, value, false);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, Vector3>> fieldExpression, Vector3 value)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return SetCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveVec3(hash);
				}, delegate(ZDO zdo, int hash, Vector3 value)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, string>> fieldExpression, string value)
			{
				return SetCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				});
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, GameObject>> fieldExpression, GameObject value)
			{
				return SetCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (GameObject x) => ((Object)x).name);
			}

			public ComponentFieldAccessor<TComponent> Set(Expression<Func<TComponent, ItemDrop>> fieldExpression, ItemDrop value)
			{
				return SetCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ItemDrop x) => ((Object)x).name);
			}

			private bool SetIfChangedCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, TObj valueObj, Action<ZDO, int>? remover, Action<ZDO, int, T> setter, Func<ZDO, int, T?, T> getter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T val = cast((TObj)field.GetValue(_component));
				T arg = cast(valueObj);
				ref T reference = ref arg;
				T val2 = default(T);
				if (val2 == null)
				{
					val2 = reference;
					reference = ref val2;
				}
				if (reference.Equals(getter((ZDO)(object)_zdo, hash, val)))
				{
					return false;
				}
				if (remover != null && arg.Equals(val))
				{
					remover((ZDO)(object)_zdo, hash);
				}
				else
				{
					if (!HasFields)
					{
						SetHasFields(value: true);
					}
					setter((ZDO)(object)_zdo, hash, arg);
				}
				return true;
			}

			private bool SetIfChangedCore<T>(Expression<Func<TComponent, T>> fieldExpression, T value, Action<ZDO, int>? remover, Action<ZDO, int, T> setter, Func<ZDO, int, T?, T> getter) where T : notnull
			{
				return SetIfChangedCore(fieldExpression, value, remover, setter, getter, (T x) => x);
			}

			public bool SetIfChanged(Expression<Func<TComponent, bool>> fieldExpression, bool value)
			{
				return SetIfChangedCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, bool value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, bool defaultValue) => zdo.GetBool(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, float>> fieldExpression, float value)
			{
				return SetIfChangedCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveFloat(hash);
				}, delegate(ZDO zdo, int hash, float value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, float defaultValue) => zdo.GetFloat(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, int>> fieldExpression, int value)
			{
				return SetIfChangedCore(fieldExpression, value, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				}, delegate(ZDO zdo, int hash, int value)
				{
					zdo.Set(hash, value, false);
				}, (ZDO zdo, int hash, int defaultValue) => zdo.GetInt(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, string>> fieldExpression, string value)
			{
				return SetIfChangedCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue));
			}

			public bool SetIfChanged(Expression<Func<TComponent, GameObject>> fieldExpression, GameObject value)
			{
				return SetIfChangedCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (GameObject x) => ((Object)x).name);
			}

			public bool SetIfChanged(Expression<Func<TComponent, ItemDrop>> fieldExpression, ItemDrop value)
			{
				return SetIfChangedCore(fieldExpression, value, null, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (ItemDrop x) => ((Object)x).name);
			}

			private ComponentFieldAccessor<TComponent> ResetCore<T>(Expression<Func<TComponent, T>> fieldExpression, Action<ZDO, int> remover)
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				remover((ZDO)(object)_zdo, hash);
				return this;
			}

			private ComponentFieldAccessor<TComponent> ResetCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, Action<ZDO, int, T> setter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T arg = cast((TObj)field.GetValue(_component));
				setter((ZDO)(object)_zdo, hash, arg);
				return this;
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, bool>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				});
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, float>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveFloat(hash);
				});
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, int>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash)
				{
					zdo.RemoveInt(hash);
				});
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, string>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (string x) => x);
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, GameObject>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (GameObject x) => ((Object)x).name);
			}

			public ComponentFieldAccessor<TComponent> Reset(Expression<Func<TComponent, ItemDrop>> fieldExpression)
			{
				return ResetCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ItemDrop x) => ((Object)x).name);
			}

			private bool ResetIfChangedCore<T>(Expression<Func<TComponent, T>> fieldExpression, Func<ZDO, int, bool> remover)
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				return remover((ZDO)(object)_zdo, hash);
			}

			private bool ResetIfChangedCore<TObj, T>(Expression<Func<TComponent, TObj>> fieldExpression, Action<ZDO, int, T> setter, Func<ZDO, int, T?, T> getter, Func<TObj, T> cast) where TObj : notnull where T : notnull
			{
				FieldInfo field;
				int hash = GetHash(fieldExpression, out field);
				T val = cast((TObj)field.GetValue(_component));
				if (getter((ZDO)(object)_zdo, hash, val).Equals(val))
				{
					return false;
				}
				setter((ZDO)(object)_zdo, hash, val);
				return true;
			}

			public bool ResetIfChanged(Expression<Func<TComponent, bool>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, (ZDO zdo, int hash) => zdo.RemoveInt(hash));
			}

			public bool ResetIfChanged(Expression<Func<TComponent, float>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, (ZDO zdo, int hash) => zdo.RemoveFloat(hash));
			}

			public bool ResetIfChanged(Expression<Func<TComponent, int>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, (ZDO zdo, int hash) => zdo.RemoveInt(hash));
			}

			public bool ResetIfChanged(Expression<Func<TComponent, string>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (string x) => x);
			}

			public bool ResetIfChanged(Expression<Func<TComponent, GameObject>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (GameObject x) => ((Object)x).name);
			}

			public bool ResetIfChanged(Expression<Func<TComponent, ItemDrop>> fieldExpression)
			{
				return ResetIfChangedCore(fieldExpression, delegate(ZDO zdo, int hash, string value)
				{
					zdo.Set(hash, value);
				}, (ZDO zdo, int hash, string? defaultValue) => zdo.GetString(hash, defaultValue), (ItemDrop x) => ((Object)x).name);
			}

			public bool SetOrReset(Expression<Func<TComponent, bool>> fieldExpression, bool set, bool setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, float>> fieldExpression, bool set, float setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, int>> fieldExpression, bool set, int setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, string>> fieldExpression, bool set, string setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, GameObject>> fieldExpression, bool set, GameObject setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}

			public bool SetOrReset(Expression<Func<TComponent, ItemDrop>> fieldExpression, bool set, ItemDrop setValue)
			{
				if (!set)
				{
					return ResetIfChanged(fieldExpression);
				}
				return SetIfChanged(fieldExpression, setValue);
			}
		}

		private sealed class ZDOInventory : IZDOInventory, IZDOInventoryReadOnly
		{
			private List<ItemData>? _items;

			private uint _dataRevision;

			private string? _lastData;

			public Inventory Inventory { get; private set; }

			public ExtendedZDO ZDO { get; private set; }

			public int? PickupRange { get; set; }

			public int? FeedRange { get; set; }

			private List<ItemData> Items
			{
				get
				{
					if (_items == null)
					{
						_items = Inventory.GetAllItems();
					}
					else if (_items != Inventory.GetAllItems())
					{
						throw new Exception("Assumption violated");
					}
					return _items;
				}
			}

			IList<ItemData> IZDOInventory.Items => Items;

			IReadOnlyList<ItemData> IZDOInventoryReadOnly.Items => Items;

			public ZDOInventory(ExtendedZDO zdo)
			{
				ZDO = zdo;
				_dataRevision = uint.MaxValue;
				base..ctor();
			}

			public ZDOInventory Update()
			{
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Expected O, but got Unknown
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Expected O, but got Unknown
				if (_dataRevision == ((ZDO)ZDO).DataRevision)
				{
					return this;
				}
				string items = ZDO.Vars.GetItems();
				if (_lastData == items)
				{
					return this;
				}
				ComponentFieldAccessor<Container> componentFieldAccessor = ZDO.Fields<Container>(getUnknownComponent: false);
				int @int = componentFieldAccessor.GetInt((Expression<Func<Container, int>>)((Container x) => x.m_width));
				int int2 = componentFieldAccessor.GetInt((Expression<Func<Container, int>>)((Container x) => x.m_height));
				if (Inventory == null || Inventory.GetWidth() != @int || Inventory.GetHeight() != int2)
				{
					Inventory = new Inventory(ZDO.PrefabInfo.Container.Value.Container.m_name, ZDO.PrefabInfo.Container.Value.Container.m_bkg, @int, int2);
				}
				if (string.IsNullOrEmpty(items))
				{
					Items.Clear();
				}
				else
				{
					Inventory.Load(new ZPackage(items));
				}
				_dataRevision = ((ZDO)ZDO).DataRevision;
				_lastData = items;
				return this;
			}

			public void UpdateZDO(ExtendedZDO zdo)
			{
				ZDO = zdo;
				_items = null;
				_dataRevision = 0u;
				_lastData = null;
				Update();
			}

			public void Save()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				ZPackage val = new ZPackage();
				Inventory.Save(val);
				uint dataRevision = ((ZDO)ZDO).DataRevision;
				string @base = val.GetBase64();
				ZDO.Vars.SetItems(@base, "D:\\a\\ValheimServersideQoL\\ValheimServersideQoL\\ValheimServersideQoL\\ExtendedZDO.cs", 662);
				if (dataRevision != ((ZDO)ZDO).DataRevision)
				{
					(Container, Piece, PieceTable, PrefabInfo.Optional<Incinerator>, PrefabInfo.Optional<ZSyncTransform>)? container = ZDO.PrefabInfo.Container;
					if (container.HasValue)
					{
						PrefabInfo.Optional<ZSyncTransform> item = container.GetValueOrDefault().Item5;
						if (item.Value != null)
						{
							ExtendedZDO zDO = ZDO;
							((ZDO)zDO).DataRevision = ((ZDO)zDO).DataRevision + 120;
						}
					}
					ZDOMan.instance.ForceSendZDO(((ZDO)ZDO).m_uid);
				}
				_dataRevision = ((ZDO)ZDO).DataRevision;
				_lastData = @base;
			}
		}

		private ZDOID _lastId = ZDOID.None;

		private AdditionalData_? _addData;

		private static readonly int __hasFieldsHash = StringExtensionMethods.GetStableHashCode("HasFields");

		private static bool _onZdoDestroyedRegistered;

		private AdditionalData_ AddData
		{
			get
			{
				//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_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				if (_lastId != base.m_uid || _addData == null)
				{
					_lastId = base.m_uid;
					if (base.m_uid != ZDOID.None)
					{
						PrefabInfo prefabInfo = SharedProcessorState.GetPrefabInfo(((ZDO)this).GetPrefab());
						if ((object)prefabInfo != null)
						{
							_addData = new AdditionalData_(prefabInfo);
							goto IL_0061;
						}
					}
					_addData = AdditionalData_.Dummy;
				}
				goto IL_0061;
				IL_0061:
				return _addData;
			}
		}

		public PrefabInfo PrefabInfo => AddData.PrefabInfo;

		public IZDOInventory Inventory
		{
			get
			{
				AdditionalData_ addData = AddData;
				ZDOInventory zDOInventory = addData.Inventory;
				if (zDOInventory == null)
				{
					if (!PrefabInfo.Container.HasValue)
					{
						throw new InvalidOperationException();
					}
					ZDOInventory zDOInventory3 = (addData.Inventory = new ZDOInventory(this));
					zDOInventory = zDOInventory3;
				}
				return zDOInventory.Update();
			}
		}

		public IZDOInventoryReadOnly InventoryReadOnly
		{
			get
			{
				AdditionalData_ addData = AddData;
				ZDOInventory zDOInventory = addData.Inventory;
				if (zDOInventory == null)
				{
					if (!PrefabInfo.Container.HasValue)
					{
						throw new InvalidOperationException();
					}
					ZDOInventory zDOInventory3 = (addData.Inventory = new ZDOInventory(this));
					zDOInventory = zDOInventory3;
				}
				return zDOInventory;
			}
		}

		public bool HasFields
		{
			get
			{
				AdditionalData_ addData = AddData;
				bool? hasFields = addData.HasFields;
				bool valueOrDefault = hasFields.GetValueOrDefault();
				if (!hasFields.HasValue)
				{
					valueOrDefault = ((ZDO)this).GetBool(__hasFieldsHash, false);
					bool? hasFields2 = valueOrDefault;
					addData.HasFields = hasFields2;
					return valueOrDefault;
				}
				return valueOrDefault;
			}
		}

		public ZDOVars_ Vars => new ZDOVars_(this);

		public IReadOnlyList<Processor> Processors => AddData.Processors;

		public DateTimeOffset OwnerTimestamp { get; private set; }

		public event RecreateHandler? Recreated
		{
			add
			{
				AdditionalData_ addData = AddData;
				addData.Recreated = (RecreateHandler)Delegate.Combine(addData.Recreated, value);
			}
			remove
			{
				AdditionalData_ addData = AddData;
				addData.Recreated = (RecreateHandler)Delegate.Remove(addData.Recreated, value);
			}
		}

		public event Action<ExtendedZDO>? Destroyed
		{
			add
			{
				if (!_onZdoDestroyedRegistered)
				{
					ZDOMan instance = ZDOMan.instance;
					instance.m_onZDODestroyed = (Action<ZDO>)Delegate.Combine(instance.m_onZDODestroyed, new Action<ZDO>(OnZdoDestroyed));
					_onZdoDestroyedRegistered = true;
				}
				AdditionalData_ addData = AddData;
				addData.Destroyed = (Action<ExtendedZDO>)Delegate.Combine(addData.Destroyed, value);
			}
			remove
			{
				AdditionalData_ addData = AddData;
				addData.Destroyed = (Action<ExtendedZDO>)Delegate.Remove(addData.Destroyed, value);
			}
		}

		public void SetModAsCreator(Processor.CreatorMarkers marker = Processor.CreatorMarkers.None)
		{
			Vars.SetCreator((long)Main.PluginGuidHash | (long)((ulong)marker << 32), "D:\\a\\ValheimServersideQoL\\ValheimServersideQoL\\ValheimServersideQoL\\ExtendedZDO.cs", 47);
		}

		public bool IsModCreator(out Processor.CreatorMarkers marker)
		{
			marker = Processor.CreatorMarkers.None;
			if ((int)Vars.GetCreator(0L) != Main.PluginGuidHash)
			{
				return false;
			}
			marker = (Processor.CreatorMarkers)((ulong)Vars.GetCreator(0L) >> 32);
			return true;
		}

		public bool IsModCreator()
		{
			Processor.CreatorMarkers marker;
			return IsModCreator(out marker);
		}

		private static void OnZdoDestroyed(ZDO zdo)
		{
			ExtendedZDO extendedZDO = (ExtendedZDO)(object)zdo;
			extendedZDO._addData?.Destroyed?.Invoke(extendedZDO);
			extendedZDO._addData = null;
		}

		private void SetHasFields()
		{
			if ((!AddData.HasFields) ?? true)
			{
				((ZDO)this).Set(__hasFieldsHash, true);
				AddData.HasFields = true;
			}
		}

		public void UnregisterProcessors(IEnumerable<Processor> processors)
		{
			AddData.Ungregister(processors);
		}

		public void UnregisterAllProcessors()
		{
			AddData.UnregisterAll();
		}

		public void ReregisterAllProcessors()
		{
			_addData?.ReregisterAll();
		}

		public void UpdateProcessorDataRevision(Processor processor)
		{
			AdditionalData_ addData = AddData;
			(addData.ProcessorDataRevisions ?? (addData.ProcessorDataRevisions = new Dictionary<Processor, (uint, uint)>()))[processor] = (((ZDO)this).DataRevision, ((ZDO)this).OwnerRevision);
		}

		public void ResetProcessorDataRevision(Processor processor)
		{
			AddData.ProcessorDataRevisions?.Remove(processor);
		}

		public bool CheckProcessorDataRevisionChanged(Processor processor)
		{
			if (AddData.ProcessorDataRevisions != null && AddData.ProcessorDataRevisions.TryGetValue(processor, out (uint, uint) value))
			{
				(uint, uint) tuple = value;
				uint dataRevision = ((ZDO)this).DataRevision;
				ushort ownerRevision = ((ZDO)this).OwnerRevision;
				if (tuple.Item1 == dataRevision && tuple.Item2 == ownerRevision)
				{
					return false;
				}
			}
			return true;
		}

		public void Destroy()
		{
			ClaimOwnershipInternal();
			ZDOMan.instance.DestroyZDO((ZDO)(object)this);
		}

		public ExtendedZDO CreateClone()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			int prefab = ((ZDO)this).GetPrefab();
			Vector3 position = ((ZDO)this).GetPosition();
			long owner = ((ZDO)this).GetOwner();
			ZPackage val = new ZPackage();
			((ZDO)this).Serialize(val);
			ExtendedZDO obj = (ExtendedZDO)(object)ZDOMan.instance.CreateNewZDO(position, prefab);
			((ZDO)obj).Deserialize(new ZPackage(val.GetArray()));
			obj.SetOwnerInternal(owner);
			return obj;
		}

		public ExtendedZDO Recreate()
		{
			ExtendedZDO extendedZDO = CreateClone();
			_addData?.Recreated?.Invoke(this, extendedZDO);
			Destroy();
			return extendedZDO;
		}

		public void SetOwner(long uid)
		{
			OwnerTimestamp = DateTimeOffset.UtcNow;
			((ZDO)this).SetOwner(uid);
		}

		public void SetOwnerInternal(long uid)
		{
			OwnerTimestamp = DateTimeOffset.UtcNow;
			((ZDO)this).SetOwnerInternal(uid);
		}

		public void ClaimOwnership()
		{
			SetOwner(ZDOMan.GetSessionID());
		}

		public void ClaimOwnershipInternal()
		{
			SetOwnerInternal(ZDOMan.GetSessionID());
		}

		public void ReleaseOwnership()
		{
			SetOwner(0L);
		}

		public void ReleaseOwnershipInternal()
		{
			SetOwnerInternal(0L);
		}

		public bool IsOwnerOrUnassigned()
		{
			if (((ZDO)this).HasOwner())
			{
				return ((ZDO)this).IsOwner();
			}
			return true;
		}

		public TimeSpan GetTimeSinceSpawned()
		{
			return ZNet.instance.GetTime() - Vars.GetSpawnTime();
		}

		public ComponentFieldAccessor<TComponent> Fields<TComponent>(bool getUnknownComponent = false) where TComponent : MonoBehaviour
		{
			if (AddData != AdditionalData_.Dummy)
			{
				AdditionalData_ addData = AddData;
				return (ComponentFieldAccessor<TComponent>)(addData.ComponentFieldAccessors ?? (addData.ComponentFieldAccessors = new ConcurrentDictionary<Type, object>())).GetOrAdd(typeof(TComponent), delegate(Type key)
				{
					if (!PrefabInfo.Components.TryGetValue(key, out MonoBehaviour value) && getUnknownComponent)
					{
						value = (MonoBehaviour)(object)PrefabInfo.Prefab.GetComponentInChildren<TComponent>();
					}
					if (value == null)
					{
						throw new KeyNotFoundException();
					}
					return new ComponentFieldAccessor<TComponent>(this, (TComponent)(object)value);
				});
			}
			if (getUnknownComponent)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(((ZDO)this).GetPrefab());
				TComponent val = ((prefab != null) ? prefab.GetComponentInChildren<TComponent>() : default(TComponent));
				if (val == null)
				{
					throw new KeyNotFoundException();
				}
				return new ComponentFieldAccessor<TComponent>(this, val);
			}
			throw new InvalidOperationException();
		}
	}
	internal static class ExtensionMethods
	{
		public static ExtendedZDO? GetExtendedZDO(this ZDOMan instance, ZDOID id)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (ExtendedZDO)(object)instance.GetZDO(id);
		}

		public static int GetActiveArea(this ZoneSystem instance)
		{
			return instance.m_activeArea - 1;
		}

		public static int GetLoadedArea(this ZoneSystem instance)
		{
			return instance.m_activeArea;
		}

		public static ConfigEntry<T> BindEx<T>(this ConfigFile config, string section, T defaultValue, string description, [CallerMemberName] string key = null)
		{
			return config.Bind<T>(section, key, defaultValue, description);
		}

		public static ConfigEntry<T> BindEx<T>(this ConfigFile config, string section, T defaultValue, string description, AcceptableValueBase? acceptableValues, [CallerMemberName] string key = null)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			return config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, acceptableValues, Array.Empty<object>()));
		}

		[Conditional("DEBUG")]
		public static void DevLog(this ManualLogSource logger, string text, LogLevel logLevel = 4)
		{
		}

		[Conditional("DEBUG")]
		public static void AssertIs<T>(this ExtendedZDO zdo) where T : MonoBehaviour
		{
		}
	}
	[BepInPlugin("argusmagnus.ServersideQoL", "ServersideQoL", "1.2.2")]
	public sealed class Main : BaseUnityPlugin
	{
		private record SectorInfo(List<Peer> Peers, List<ZDO> ZDOs)
		{
			public int InverseWeight { get; set; }
		}

		private sealed class PeersEnumerable : IEnumerable<Peer>, IEnumerable
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__6 : IEnumerator<Peer>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private Peer <>2__current;

				public PeersEnumerable <>4__this;

				private IEnumerator<ZNetPeer> <>7__wrap1;

				Peer IEnumerator<Peer>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

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

				[DebuggerHidden]
				public <GetEnumerator>d__6(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || num == 2)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<>7__wrap1 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					try
					{
						int num = <>1__state;
						PeersEnumerable peersEnumerable = <>4__this;
						switch (num)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							if (peersEnumerable._localPeer != null)
							{
								<>2__current = new Peer(peersEnumerable._localPeer);
								<>1__state = 1;
								return true;
							}
							goto IL_0059;
						case 1:
							<>1__state = -1;
							goto IL_0059;
						case 2:
							{
								<>1__state = -3;
								break;
							}
							IL_0059:
							<>7__wrap1 = peersEnumerable._peers.GetEnumerator();
							<>1__state = -3;
							break;
						}
						if (<>7__wrap1.MoveNext())
						{
							ZNetPeer current = <>7__wrap1.Current;
							<>2__current = new Peer(current);
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

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

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>7__wrap1 != null)
					{
						<>7__wrap1.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}
			}

			private readonly ZNetPeer? _localPeer;

			private IReadOnlyList<ZNetPeer> _peers;

			public int Count => _peers.Count + ((_localPeer != null) ? 1 : 0);

			public PeersEnumerable(ZNetPeer? localPeer)
			{
				_localPeer = localPeer;
				_peers = Array.Empty<ZNetPeer>();
				base..ctor();
			}

			public void Update()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (_localPeer != null)
				{
					_localPeer.m_refPos = ZNet.instance.GetReferencePosition();
				}
				_peers = ZNet.instance.GetPeers();
			}

			[IteratorStateMachine(typeof(<GetEnumerator>d__6))]
			public IEnumerator<Peer> GetEnumerator()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <GetEnumerator>d__6(0)
				{
					<>4__this = this
				};
			}

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

		private sealed class MyTerminal : Terminal
		{
			private sealed class MyConsoleEventArgs : ConsoleEventArgs
			{
				public MyConsoleEventArgs(string command, params string[] args)
					: base("", (Terminal)null)
				{
					int num = 0;
					string[] array = new string[1 + args.Length];
					array[num] = command;
					num++;
					ReadOnlySpan<string> readOnlySpan = new ReadOnlySpan<string>(args);
					readOnlySpan.CopyTo(new Span<string>(array).Slice(num, readOnlySpan.Length));
					num += readOnlySpan.Length;
					base.Args = array;
				}
			}

			protected override Terminal m_terminalInstance
			{
				get
				{
					throw new NotImplementedException();
				}
			}

			public static void ExecuteCommand(string command, params string[] args)
			{
				ConsoleCommand command2 = Terminal.commands[command];
				ConsoleEvent action = command2.GetAction();
				if (action != null)
				{
					action.Invoke((ConsoleEventArgs)(object)new MyConsoleEventArgs(command, args));
					return;
				}
				ConsoleEventFailable actionFailable = command2.GetActionFailable();
				if (actionFailable != null)
				{
					object obj = actionFailable.Invoke((ConsoleEventArgs)(object)new MyConsoleEventArgs(command, args));
					if (obj is bool && (bool)obj)
					{
						return;
					}
					throw new Exception(obj.ToString());
				}
				throw new ArgumentException("command");
			}
		}

		private sealed class DummySocket : ISocket
		{
			public ISocket Accept()
			{
				throw new NotImplementedException();
			}

			public void Close()
			{
			}

			public void Dispose()
			{
			}

			public bool Flush()
			{
				throw new NotImplementedException();
			}

			public void GetAndResetStats(out int totalSent, out int totalRecv)
			{
				throw new NotImplementedException();
			}

			public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
			{
				throw new NotImplementedException();
			}

			public int GetCurrentSendRate()
			{
				throw new NotImplementedException();
			}

			public string GetEndPointString()
			{
				throw new NotImplementedException();
			}

			public string GetHostName()
			{
				return "";
			}

			public int GetHostPort()
			{
				throw new NotImplementedException();
			}

			public int GetSendQueueSize()
			{
				throw new NotImplementedException();
			}

			public bool GotNewData()
			{
				throw new NotImplementedException();
			}

			public bool IsConnected()
			{
				return true;
			}

			public bool IsHost()
			{
				throw new NotImplementedException();
			}

			public ZPackage Recv()
			{
				throw new NotImplementedException();
			}

			public void Send(ZPackage pkg)
			{
				throw new NotImplementedException();
			}

			public void VersionMatch()
			{
				throw new NotImplementedException();
			}
		}

		[CompilerGenerated]
		private sealed class <<Start>g__CallExecute|35_0>d : IEnumerator<YieldInstruction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private YieldInstruction <>2__current;

			public Main <>4__this;

			private PeersEnumerable <peers>5__2;

			YieldInstruction IEnumerator<YieldInstruction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <<Start>g__CallExecute|35_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<peers>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Expected O, but got Unknown
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Expected O, but got Unknown
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				int num = <>1__state;
				Main main = <>4__this;
				ZNetPeer localPeer;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_005b;
				case 1:
					<>1__state = -1;
					goto IL_005b;
				case 2:
					<>1__state = -1;
					goto IL_005b;
				case 3:
					<>1__state = -1;
					goto IL_00c0;
				case 4:
					<>1__state = -1;
					goto IL_005b;
				case 5:
					<>1__state = -1;
					goto IL_0132;
				case 6:
					{
						<>1__state = -1;
						if (ZNet.instance != null)
						{
							try
							{
								main.Execute(<peers>5__2);
							}
							catch (OperationCanceledException)
							{
								return false;
							}
							catch (Exception ex2)
							{
								main.Logger.LogError((object)ex2);
								return false;
							}
							break;
						}
						<peers>5__2 = null;
						goto IL_005b;
					}
					IL_00c0:
					if (ZDOMan.instance == null || ZNetScene.instance == null || ZNet.World == null)
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(0.2f);
						<>1__state = 3;
						return true;
					}
					if (!main.Initialize())
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(5f);
						<>1__state = 4;
						return true;
					}
					localPeer = null;
					if (!ZNet.instance.IsDedicated())
					{
						goto IL_0132;
					}
					goto IL_0167;
					IL_0132:
					if (Player.m_localPlayer == null)
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(0.2f);
						<>1__state = 5;
						return true;
					}
					localPeer = new ZNetPeer((ISocket)(object)new DummySocket(), true)
					{
						m_uid = ZDOMan.GetSessionID(),
						m_characterID = ((Character)Player.m_localPlayer).GetZDOID(),
						m_server = true
					};
					goto IL_0167;
					IL_005b:
					if (ZNet.instance == null)
					{
						<>2__current = (YieldInstruction)new WaitForSeconds(0.2f);
						<>1__state = 1;
						return true;
					}
					if (!ZNet.instance.IsServer())
					{
						main.Logger.LogWarning((object)"Mod should only be installed on the host");
						<>2__current = (YieldInstruction)new WaitForSeconds(5f);
						<>1__state = 2;
						return true;
					}
					goto IL_00c0;
					IL_0167:
					<peers>5__2 = new PeersEnumerable(localPeer);
					break;
				}
				<>2__current = (YieldInstruction)new WaitForSeconds(1f / main.Config.General.Frequency.Value);
				<>1__state = 6;
				return true;
			}

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

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		internal const string PluginName = "ServersideQoL";

		internal const string PluginGuid = "argusmagnus.ServersideQoL";

		private ModConfig? _mainConfig;

		private ModConfig? _worldConfig;

		private readonly Stopwatch _watch = new Stopwatch();

		private ulong _executeCounter;

		private uint _unfinishedProcessingInRow;

		private readonly Stack<SectorInfo> _sectorInfoPool = new Stack<SectorInfo>();

		private Dictionary<Vector2i, SectorInfo> _playerSectors = new Dictionary<Vector2i, SectorInfo>();

		private Dictionary<Vector2i, SectorInfo> _playerSectorsOld = new Dictionary<Vector2i, SectorInfo>();

		private readonly List<Processor> _unregister = new List<Processor>();

		private bool _configChanged = true;

		private readonly GameVersion ExpectedGameVersion = GameVersion.ParseGameVersion("0.221.4");

		private const uint ExpectedNetworkVersion = 35u;

		private const uint ExpectedItemDataVersion = 106u;

		private const uint ExpectedWorldVersion = 36u;

		internal const string DummyConfigSection = "Z - Dummy";

		private const string PluginVersion = "1.2.2";

		internal const string PluginInformationalVersion = "1.2.2-beta.0.13";

		internal static int PluginGuidHash { get; } = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL");


		internal static Main Instance { get; private set; } = null;


		internal static Harmony HarmonyInstance { get; } = new Harmony("argusmagnus.ServersideQoL");


		internal ManualLogSource Logger { get; } = Logger.CreateLogSource("ServersideQoL");


		internal ModConfig Config => _worldConfig ?? _mainConfig ?? (_mainConfig = new ModConfig(((BaseUnityPlugin)this).Config));

		public Main()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
		}

		private void Awake()
		{
			Logger.LogWarning((object)"You are running a pre-release version: 1.2.2-beta.0.13");
			HarmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine((IEnumerator)CallExecute());
			[IteratorStateMachine(typeof(<<Start>g__CallExecute|35_0>d))]
			IEnumerator<YieldInstruction> CallExecute()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<Start>g__CallExecute|35_0>d(0)
				{
					<>4__this = this
				};
			}
		}

		private bool Initialize()
		{
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			if ((object)_mainConfig != null)
			{
				_mainConfig.ConfigFile.SettingChanged -= OnConfigChanged;
			}
			if ((object)_worldConfig != null)
			{
				_worldConfig.ConfigFile.SettingChanged -= OnConfigChanged;
			}
			_worldConfig = null;
			_executeCounter = 0uL;
			if (Config.General.ConfigPerWorld.Value)
			{
				string rootPath = ZNet.World.GetRootPath((FileSource)1);
				rootPath += ".ServersideQoL.cfg";
				if (!File.Exists(rootPath) && File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath))
				{
					File.Copy(((BaseUnityPlugin)this).Config.ConfigFilePath, rootPath);
				}
				string path = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Config.ConfigFilePath), Path.GetFileNameWithoutExtension(((BaseUnityPlugin)this).Config.ConfigFilePath));
				if (Directory.Exists(path))
				{
					string text = Path.Combine(Path.GetDirectoryName(rootPath), Path.GetFileNameWithoutExtension(rootPath));
					Directory.CreateDirectory(text);
					foreach (string item in Directory.EnumerateFiles(path))
					{
						string text2 = Path.Combine(text, Path.GetFileName(item));
						if (!File.Exists(text2))
						{
							File.Copy(item, text2);
						}
					}
				}
				Logger.LogInfo((object)"Using world config file");
				_worldConfig = new ModConfig(new ConfigFile(rootPath, false, new BepInPlugin("argusmagnus.ServersideQoL", "ServersideQoL", "1.2.2")));
			}
			Logger.LogInfo((object)FormattableString.Invariant($"Enabled: {Config.General.Enabled.Value}, DiagnosticLogs: {Config.General.DiagnosticLogs.Value}"));
			if (!Config.General.Enabled.Value)
			{
				return false;
			}
			if (Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.dedicatedserver", out var value))
			{
				Logger.LogWarning((object)("Many features are incompatible with " + value.Metadata.Name));
			}
			if (Config.General.DiagnosticLogs.Value)
			{
				ManualLogSource logger = Logger;
				string separator = Environment.NewLine + "  ";
				List<string> list = new List<string>();
				list.Add("Config:");
				list.AddRange(((IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)Config.ConfigFile).Select((KeyValuePair<ConfigDefinition, ConfigEntryBase> x) => FormattableString.Invariant($"[{x.Key.Section}].[{x.Key.Key}] = {x.Value.BoxedValue}")));
				logger.LogInfo((object)string.Join(separator, list.ToArray()));
			}
			bool flag = false;
			bool flag2 = false;
			if (RuntimeInformation.Instance.GameVersion != ExpectedGameVersion)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported game version: {RuntimeInformation.Instance.GameVersion}, expected: {ExpectedGameVersion}"));
				flag = true;
				flag2 |= !Config.General.IgnoreGameVersionCheck.Value;
			}
			if (RuntimeInformation.Instance.NetworkVersion != 35)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported network version: {RuntimeInformation.Instance.NetworkVersion}, expected: {35u}"));
				flag = true;
				flag2 |= !Config.General.IgnoreNetworkVersionCheck.Value;
			}
			if ((long)RuntimeInformation.Instance.ItemDataVersion != 106)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported item data version: {RuntimeInformation.Instance.ItemDataVersion}, expected: {106u}"));
				flag = true;
				flag2 |= !Config.General.IgnoreItemDataVersionCheck.Value;
			}
			if ((long)RuntimeInformation.Instance.WorldVersion != 36)
			{
				Logger.LogWarning((object)FormattableString.Invariant($"Unsupported world version: {RuntimeInformation.Instance.WorldVersion}, expected: {36u}"));
				flag = true;
				flag2 |= !Config.General.IgnoreWorldVersionCheck.Value;
			}
			if (flag)
			{
				if (flag2)
				{
					Logger.LogError((object)"Version checks failed. Mod execution is stopped");
					return false;
				}
				Logger.LogError((object)"Version checks failed, but you chose to ignore the checks (config). Continuing...");
			}
			return true;
		}

		private void OnConfigChanged(object sender, SettingChangedEventArgs e)
		{
			_configChanged = true;
			if (Config.General.DiagnosticLogs.Value || e.ChangedSetting == Config.General.DiagnosticLogs)
			{
				Logger.LogInfo((object)$"Config changed: [{e.ChangedSetting.Definition.Section}].[{e.ChangedSetting.Definition.Key}] = {e.ChangedSetting.BoxedValue}");
			}
			if (e.ChangedSetting == Config.General.DiagnosticLogs && Config.General.DiagnosticLogs.Value)
			{
				ManualLogSource logger = Logger;
				string separator = Environment.NewLine + "  ";
				List<string> list = new List<string>();
				list.Add("Config:");
				list.AddRange(((IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)Config.ConfigFile).Select((KeyValuePair<ConfigDefinition, ConfigEntryBase> x) => FormattableString.Invariant($"[{x.Key.Section}].[{x.Key.Key}] = {x.Value.BoxedValue}")));
				logger.LogInfo((object)string.Join(separator, list.ToArray()));
			}
		}

		private void Execute(PeersEnumerable peers)
		{
			//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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Unknown result type (might be due to invalid IL or missing references)
			//IL_0620: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0633: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0768: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a85: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0860: Unknown result type (might be due to invalid IL or missing references)
			_executeCounter++;
			if (_configChanged)
			{
				_configChanged = false;
				if (Config.GlobalsKeys.SetGlobalKeysFromConfig.Value)
				{
					ZoneSystem.instance.ResetWorldKeys();
				}
				if (Config.WorldModifiers.SetPresetFromConfig.Value)
				{
					try
					{
						MyTerminal.ExecuteCommand("setworldpreset", FormattableString.Invariant($"{Config.WorldModifiers.Preset.Value}"));
					}
					catch (Exception ex)
					{
						Logger.LogError((object)ex);
					}
				}
				if (Config.WorldModifiers.SetModifiersFromConfig.Value)
				{
					foreach (var (val, val2) in Config.WorldModifiers.Modifiers.Select<KeyValuePair<WorldModifiers, ConfigEntry<WorldModifierOption>>, (WorldModifiers, WorldModifierOption)>((KeyValuePair<WorldModifiers, ConfigEntry<WorldModifierOption>> x) => (x.Key, x.Value.Value)))
					{
						try
						{
							MyTerminal.ExecuteCommand("setworldmodifier", FormattableString.Invariant($"{val}"), FormattableString.Invariant($"{val2}"));
						}
						catch (Exception ex2)
						{
							Logger.LogError((object)ex2);
						}
					}
				}
				if (Config.GlobalsKeys.SetGlobalKeysFromConfig.Value)
				{
					foreach (KeyValuePair<GlobalKeys, ConfigEntryBase> item3 in Config.GlobalsKeys.KeyConfigs.Where<KeyValuePair<GlobalKeys, ConfigEntryBase>>((KeyValuePair<GlobalKeys, ConfigEntryBase> x) => !object.Equals(x.Value.BoxedValue, x.Value.DefaultValue)))
					{
						item3.Deconstruct(out var key, out var value);
						GlobalKeys val3 = key;
						ConfigEntryBase val4 = value;
						object boxedValue = val4.BoxedValue;
						if (boxedValue is bool)
						{
							if ((bool)boxedValue)
							{
								ZoneSystem.instance.SetGlobalKey(val3);
							}
							else
							{
								ZoneSystem.instance.RemoveGlobalKey(val3);
							}
							continue;
						}
						float num;
						try
						{
							num = (float)Convert.ChangeType(val4.BoxedValue, typeof(float));
						}
						catch (Exception ex3)
						{
							Logger.LogError((object)ex3);
							continue;
						}
						ZoneSystem.instance.SetGlobalKey(val3, num);
					}
				}
				foreach (Processor defaultProcessor in Processor.DefaultProcessors)
				{
					defaultProcessor.Initialize(_executeCounter == 1);
				}
				if (_executeCounter == 1)
				{
					Config.ConfigFile.SettingChanged -= OnConfigChanged;
					Config.ConfigFile.SettingChanged += OnConfigChanged;
					return;
				}
				{
					foreach (ExtendedZDO item4 in ZDOMan.instance.GetObjectsByID().Values.Cast<ExtendedZDO>())
					{
						item4.ReregisterAllProcessors();
					}
					return;
				}
			}
			_watch.Restart();
			peers.Update();
			SharedProcessorState.CleanUp(peers);
			if (peers.Count == 0)
			{
				return;
			}
			Dictionary<Vector2i, SectorInfo> playerSectorsOld = _playerSectorsOld;
			Dictionary<Vector2i, SectorInfo> playerSectors = _playerSectors;
			_playerSectors = playerSectorsOld;
			_playerSectorsOld = playerSectors;
			Vector2i key2 = default(Vector2i);
			foreach (Peer peer in peers)
			{
				Vector2i zone = ZoneSystem.GetZone(peer.m_refPos);
				for (int i = zone.x - Config.General.ZonesAroundPlayers.Value; i <= zone.x + Config.General.ZonesAroundPlayers.Value; i++)
				{
					for (int j = zone.y - Config.General.ZonesAroundPlayers.Value; j <= zone.y + Config.General.ZonesAroundPlayers.Value; j++)
					{
						((Vector2i)(ref key2))..ctor(i, j);
						if (_playerSectorsOld.Remove(key2, out SectorInfo value2))
						{
							_playerSectors.Add(key2, value2);
							value2.InverseWeight = 0;
							value2.Peers.Clear();
							value2.Peers.Add(peer);
							continue;
						}
						if (_playerSectors.TryGetValue(key2, out value2))
						{
							value2.Peers.Add(peer);
							continue;
						}
						if (_sectorInfoPool.TryPop(out value2))
						{
							value2.Peers.Add(peer);
						}
						else
						{
							value2 = new SectorInfo(new List<Peer>(1) { peer }, new List<ZDO>());
						}
						_playerSectors.Add(key2, value2);
					}
				}
			}
			foreach (SectorInfo value3 in _playerSectorsOld.Values)
			{
				value3.InverseWeight = 0;
				value3.Peers.Clear();
				value3.ZDOs.Clear();
				_sectorInfoPool.Push(value3);
			}
			_playerSectorsOld.Clear();
			IEnumerable<KeyValuePair<Vector2i, SectorInfo>> enumerable = _playerSectors.AsEnumerable();
			if (_unfinishedProcessingInRow > 10)
			{
				foreach (Peer peer2 in peers)
				{
					Vector2i zone2 = ZoneSystem.GetZone(peer2.m_refPos);
					foreach (var item5 in _playerSectors.Select<KeyValuePair<Vector2i, SectorInfo>, (Vector2i, SectorInfo)>((KeyValuePair<Vector2i, SectorInfo> x) => (x.Key, x.Value)))
					{
						Vector2i item = item5.Item1;
						SectorInfo item2 = item5.Item2;
						int num2 = item.x - zone2.x;
						int num3 = item.y - zone2.y;
						item2.InverseWeight += num2 * num2 + num3 * num3;
					}
				}
				enumerable = enumerable.OrderBy((KeyValuePair<Vector2i, SectorInfo> x) => x.Value.InverseWeight);
			}
			foreach (Processor defaultProcessor2 in Processor.DefaultProcessors)
			{
				defaultProcessor2.PreProcess(peers);
			}
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			foreach (var (val6, sectorInfo2) in enumerable)
			{
				if (_watch.ElapsedMilliseconds >= Config.General.MaxProcessingTime.Value)
				{
					break;
				}
				num4++;
				if ((object)sectorInfo2 != null)
				{
					List<ZDO> zDOs = sectorInfo2.ZDOs;
					if (zDOs != null && zDOs.Count == 0)
					{
						ZDOMan.instance.FindSectorObjects(val6, 0, 0, sectorInfo2.ZDOs, (List<ZDO>)null);
					}
				}
				num6 += sectorInfo2.ZDOs.Count;
				while ((object)sectorInfo2 != null)
				{
					List<ZDO> zDOs = sectorInfo2.ZDOs;
					if (zDOs == null || zDOs.Count <= 0 || _watch.ElapsedMilliseconds >= Config.General.MaxProcessingTime.Value)
					{
						break;
					}
					num5++;
					ExtendedZDO extendedZDO = (ExtendedZDO)(object)sectorInfo2.ZDOs[sectorInfo2.ZDOs.Count - 1];
					sectorInfo2.ZDOs.RemoveAt(sectorInfo2.ZDOs.Count - 1);
					if (!((ZDO)extendedZDO).IsValid())
					{
						continue;
					}
					if (extendedZDO.Processors.Count > 1)
					{
						Processor claimedExclusiveBy = null;
						foreach (Processor processor in extendedZDO.Processors)
						{
							if (processor.ClaimExclusive(extendedZDO))
							{
								if (claimedExclusiveBy == null)
								{
									claimedExclusiveBy = processor;
								}
								else if (Config.General.DiagnosticLogs.Value)
								{
									Logger.LogError((object)FormattableString.Invariant($"ZDO {((ZDO)extendedZDO).m_uid} claimed exclusive by {processor.GetType().Name} while already claimed by {claimedExclusiveBy.GetType().Name}"));
								}
							}
						}
						if (claimedExclusiveBy != null)
						{
							extendedZDO.UnregisterProcessors(extendedZDO.Processors.Where((Processor x) => x != claimedExclusiveBy));
						}
					}
					bool flag = false;
					bool flag2 = false;
					_unregister.Clear();
					foreach (Processor processor2 in extendedZDO.Processors)
					{
						processor2.Process(extendedZDO, sectorInfo2.Peers);
						if (processor2.UnregisterZdoProcessor)
						{
							_unregister.Add(processor2);
						}
						if (flag = processor2.DestroyZdo)
						{
							extendedZDO.Destroy();
							break;
						}
						flag2 = flag2 || processor2.RecreateZdo;
					}
					if (!flag && flag2)
					{
						extendedZDO.Recreate();
					}
					else if (!flag && _unregister.Count > 0)
					{
						extendedZDO.UnregisterProcessors(_unregister);
					}
				}
			}
			foreach (Processor defaultProcessor3 in Processor.DefaultProcessors)
			{
				defaultProcessor3.PostProcess();
			}
			if (num4 < _playerSectors.Count || num5 < num6)
			{
				_unfinishedProcessingInRow++;
			}
			else
			{
				_unfinishedProcessingInRow = 0u;
			}
			_watch.Stop();
			if (Config.General.DiagnosticLogs.Value)
			{
				LogLevel val7 = (LogLevel)((_unfinishedProcessingInRow == 0) ? 32 : 16);
				Logger.Log(val7, (object)FormattableString.Invariant(FormattableStringFactory.Create("{0} took {1} ms to process {2} of {3} ZDOs in {4} of {5} zones. Incomplete runs in row: {6}", "Execute", _watch.ElapsedMilliseconds, num5, num6, num4, _playerSectors.Count, _unfinishedProcessingInRow)));
				Logger.Log(val7, (object)FormattableString.Invariant(FormattableStringFactory.Create("Processing Time: {0}", string.Join(", ", from x in Processor.DefaultProcessors
					where x.ProcessingTime.Ticks > 0
					orderby x.ProcessingTime.Ticks descending
					select FormattableString.Invariant($"{x.GetType().Name}: {x.ProcessingTime.TotalMilliseconds}ms")))));
			}
		}
	}
	public enum MessageTypes
	{
		None,
		TopLeftNear,
		TopLeftFar,
		CenterNear,
		CenterFar,
		InWorld
	}
	internal sealed record ModConfig(ConfigFile ConfigFile)
	{
		public sealed class GeneralConfig
		{
			public ConfigEntry<bool> Enabled { get; } = cfg.BindEx(section, defaultValue: true, "Enables/disables the entire mod", "Enabled");


			public ConfigEntry<bool> ConfigPerWorld { get; } = cfg.BindEx(section, defaultValue: false, "Use one config file per world. The file is saved next to the world file", "ConfigPerWorld");


			public ConfigEntry<bool> InWorldConfigRoom { get; } = cfg.BindEx(section, defaultValue: false, "True to generate an in-world room which admins can enter to configure this mod by editing signs. A portal is placed at the start location", "InWorldConfigRoom");


			public ConfigEntry<float> FarMessageRange { get; } = cfg.BindEx(section, 64f, $"Max distance a player can have to a modified object to receive messages of type {MessageTypes.TopLeftFar} or {MessageTypes.CenterFar}", "FarMessageRange");


			public ConfigEntry<bool> DiagnosticLogs { get; } = cfg.BindEx(section, defaultValue: false, "Enables/disables diagnostic logs", "DiagnosticLogs");


			public ConfigEntry<float> Frequency { get; } = cfg.BindEx(section, 5f, "How many times per second the mod processes the world", (AcceptableValueBase?)(object)new AcceptableValueRange<float>(0f, float.PositiveInfinity), "Frequency");


			public ConfigEntry<int> MaxProcessingTime { get; } = cfg.BindEx(section, 20, "Max processing time (in ms) per update", "MaxProcessingTime");


			public ConfigEntry<int> ZonesAroundPlayers { get; } = cfg.BindEx(section, ZoneSystem.instance.GetActiveArea(), "Zones to process around each player", "ZonesAroundPlayers");


			public ConfigEntry<float> MinPlayerDistance { get; } = cfg.BindEx(section, 4f, "Min distance all players must have to a ZDO for it to be modified", "MinPlayerDistance");


			public ConfigEntry<bool> IgnoreGameVersionCheck { get; } = cfg.BindEx(section, defaultValue: true, "True to ignore the game version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption", "IgnoreGameVersionCheck");


			public ConfigEntry<bool> IgnoreNetworkVersionCheck { get; } = cfg.BindEx(section, defaultValue: false, "True to ignore the network version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption", "IgnoreNetworkVersionCheck");


			public ConfigEntry<bool> IgnoreItemDataVersionCheck { get; } = cfg.BindEx(section, defaultValue: false, "True to ignore the item data version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption", "IgnoreItemDataVersionCheck");


			public ConfigEntry<bool> IgnoreWorldVersionCheck { get; } = cfg.BindEx(section, defaultValue: false, "True to ignore the world version check. Turning this off may lead to the mod being run in an untested version and may lead to data loss/world corruption", "IgnoreWorldVersionCheck");


			public GeneralConfig(ConfigFile cfg, string section)
			{
			}
		}

		public sealed class SignsConfig
		{
			public ConfigEntry<string> DefaultColor { get; } = cfg.BindEx(section, "", "Default color for signs. Can be a color name or hex code (e.g. #FF0000 for red)", "DefaultColor");


			public ConfigEntry<bool> TimeSigns { get; } = cfg.BindEx(section, defaultValue: false, FormattableString.Invariant($"True to update sign texts which contain time emojis (any of {string.Concat(SignProcessor.ClockEmojis)}) with the in-game time"), "TimeSigns");


			public SignsConfig(ConfigFile cfg, string section)
			{
			}
		}

		public sealed class MapTableConfig
		{
			public ConfigEntry<bool> AutoUpdatePortals { get; } = cfg.BindEx(section, defaultValue: false, "True to update map tables with portal pins", "AutoUpdatePortals");


			public ConfigEntry<string> AutoUpdatePortalsExclude { get; } = cfg.BindEx(section, "", "Portals with a tag that matches this filter are not added to map tables", "AutoUpdatePortalsExclude");


			public ConfigEntry<string> AutoUpdatePortalsInclude { get; } = cfg.BindEx(section, "*", "Only portals with a tag that matches this filter are added to map tables", "AutoUpdatePortalsInclude");


			public ConfigEntry<bool> AutoUpdateShips { get; } = cfg.BindEx(section, defaultValue: false, "True to update map tables with ship pins", "AutoUpdateShips");


			public ConfigEntry<MessageTypes> UpdatedMessageType { get; } = cfg.BindEx(section, MessageTypes.None, "Type of message to show when a map table is updated", (AcceptableValueBase?)(object)AcceptableEnum<MessageTypes>.Default, "UpdatedMessageType");


			public MapTableConfig(ConfigFile cfg, string section)
			{
			}
		}

		public sealed class TamesConfig
		{
			public ConfigEntry<bool> MakeCommandable { get; } = cfg.BindEx(section, defaultValue: false, "True to make all tames commandable (like wolves)", "MakeCommandable");


			public ConfigEntry<MessageTypes> TamingProgressMessageType { get; } = cfg.BindEx(section, MessageTypes.None, "Type of taming progress messages to show", (AcceptableValueBase?)(object)AcceptableEnum<MessageTypes>.Default, "TamingProgressMessageType");


			public ConfigEntry<MessageTypes> GrowingProgressMessageType { get; } = cfg.BindEx(section, MessageTypes.None, "Type of growing progress messages to show", (AcceptableValueBase?)(object)AcceptableEnum<MessageTypes>.Default, "GrowingProgressMessageType");


			public ConfigEntry<float> FedDurationMultiplier { get; } = cfg.BindEx(section, 1f, FormattableString.Invariant($"Multiply the time tames stay fed after they have eaten by this factor. {float.PositiveInfinity} to keep them fed indefinitely"), "FedDurationMultiplier");


			public ConfigEntry<float> TamingTimeMultiplier { get; } = cfg.BindEx(section, 1f, "Multiply the time it takes to tame a tameable creature by this factor.\r\nE.g. a value of 0.5 means that the taming time is halved.", "TamingTimeMultiplier");


			public ConfigEntry<float> PotionTamingBoostMultiplier { get; } = cfg.BindEx(section, 1f, "Multiply the taming boost from the animal whispers potion by this factor.\r\nE.g. a value of 2 means that the effect of the potion is doubled and the resulting taming time is reduced by a factor of 4 per player.", "PotionTamingBoostMultiplier");


			public ConfigEntry<bool> TeleportFollow { get; } = cfg.BindEx(section, defaultValue: false, "True to teleport following tames to the players location if the player gets too far away from them", "TeleportFollow");


			public ConfigEntry<bool> TakeIntoDungeons { get; } = cfg.BindEx(section, defaultValue: false, "True to take following tames into (and out of) dungeons with you", "TakeIntoDungeons");


			public TamesConfig(ConfigFile cfg, string section)
			{
			}
		}

		public sealed class CreaturesConfig
		{
			[Flags]
			public enum ShowHigherLevelAuraOptions
			{
				Never = 0,
				Wild = 1,
				Tamed = 2
			}

			public ConfigEntry<bool> ShowHigherLevelStars { get; } = cfg.BindEx(section, defaultValue: false, "True to show stars for higher level creatures (> 2 stars)", "ShowHigherLevelStars");


			public ConfigEntry<ShowHigherLevelAuraOptions> ShowHigherLevelAura { get; } = cfg.BindEx(section, ShowHigherLevelAuraOptions.Never, "Show an aura for higher level creatures (> 2 stars)", (AcceptableValueBase?)(object)AcceptableEnum<ShowHigherLevelAuraOptions>.Default, "ShowHigherLevelAura");


			public ConfigEntry<int> MaxLevelIncrease { get; } = cfg.BindEx(section, 0, "Amount the max level of creatures is incremented throughout the world.\r\nThe level up chance increases with the max level.\r\nExample: if this value is set to 2, a creature will spawn with 4 stars with the same probability as it would spawn with 2 stars without this setting.", "MaxLevelIncrease");


			public ConfigEntry<int> MaxLevelIncreasePerDefeatedBoss { get; } = cfg.BindEx(section, 0, "Amount the max level of creatures is incremented per defeated boss.\r\nThe respective boss's biome and previous biomes are affected and the level up chance increases with the max level.\r\nExample: If this value is set to 1 and Eikthyr and the Elder is defeated, the max creature level in the Black Forest will be raised by 1 and in the Meadows by 2.", "MaxLevelIncreasePerDefeatedBoss");


			public ConfigEntry<Biome> TreatOceanAs { get; } = cfg.BindEx<Biome>(section, (Biome)8, "Biome to treat the ocean as for the purpose of leveling up creatures", (AcceptableValueBase?)(object)new AcceptableEnum<Biome>(AcceptableEnum<Biome>.Default.AcceptableValues.Where((Biome x) => (int)x != 256)), "TreatOceanAs");


			public ConfigEntry<bool> LevelUpBosses { get; } = cfg.BindEx(section, defaultValue: false, "True to also level up bosses", "LevelUpBosses");


			public ConfigEntry<float> RespawnOneTimeSpawnsAfter { get; } = cfg.BindEx(section, 0f, "Time after one-time spawns are respawned in minutes", "RespawnOneTimeSpawnsAfter");


			public CreaturesConfig(ConfigFile cfg, string section)
			{
			}
		}

		public sealed class FireplacesConfig
		{
			public enum IgnoreRainOptions
			{
				Never,
				Always,
				InsideShield
			}

			public ConfigEntry<bool> MakeToggleable { get; } = cfg.BindEx(section, defaultValue: false, "True to make all fireplaces (including torches, braziers, etc.) toggleable", "MakeToggleable");


			public ConfigEntry<bool> InfiniteFuel { get; } = cfg.BindEx(section, defaultValue: false, "True to make all fireplaces have infinite fuel", "InfiniteFuel");


			public ConfigEntry<IgnoreRainOptions> IgnoreRain { get; } = cfg.BindEx(section, IgnoreRainOptions.Never, "Options to make all fireplaces ignore rain", (AcceptableValueBase?)(object)AcceptableEnum<IgnoreRainOptions>.Default, "IgnoreRain");


			public FireplacesConfig(ConfigFile cfg, string section)
			{
			}
		}

		public sealed class ContainersConfig
		{
			public enum ObliteratorItemTeleporterOptions
			{
				Disabled = 0,
				Enabled = 1,
				EnabledAllItems = 2,
				[Obsolete]
				False = 0,
				[Obsolete]
				True = 1
			}

			[Flags]
			public enum SignOptions
			{
				None = 0,
				Left = 1,
				Right = 2,
				Front = 4,
				Back = 8,
				TopLongitudinal = 0x10,
				TopLateral = 0x20
			}

			private const string ChestSignItemNamesFileName = "ChestSignItemNames.yml";

			private const string DefaultPlaceholderString = "•";

			public ConfigEntry<bool> AutoSort { get; }

			public ConfigEntry<MessageTypes> SortedMessageType { get; }

			public ConfigEntry<bool> AutoPickup { get; }

			public ConfigEntry<float> AutoPickupRange { get; }

			public ConfigEntry<int> AutoPickupMaxRange { get; }

			public ConfigEntry<float> AutoPickupMinPlayerDistance { get; }

			public ConfigEntry<bool> AutoPickupExcludeFodder { get; }

			public ConfigEntry<bool> AutoPickupRequestOwnership { get; }

			public ConfigEntry<MessageTypes> PickedUpMessageType { get; }

			public ConfigEntry<string> ChestSignsDefaultText { get; }

			public ConfigEntry<string> ChestSignsContentListPlaceholder { get; }

			public ConfigEntry<int> ChestSignsContentListMaxCount { get; }

			public ConfigEntry<string> ChestSignsContentListSeparator { get; }

			public ConfigEntry<string> ChestSignsContentListNameRest { get; }

			public ConfigEntry<string> ChestSignsContentListEntryFormat { get; }

			public ConfigEntry<SignOptions> WoodChestSigns { get; }

			public ConfigEntry<SignOptions> ReinforcedChestSigns { get; }

			public ConfigEntry<SignOptions> BlackmetalChestSigns { get; }

			public ConfigEntry<SignOptions> ObliteratorSigns { get; }

			public ConfigEntry<ObliteratorItemTeleporterOptions> ObliteratorItemTeleporter { get; }

			public ConfigEntry<MessageTypes> ObliteratorItemTeleporterMessageType { get; }

			public IReadOnlyDictionary<int, ConfigEntry<string>> ContainerSizes { get; }

			public IReadOnlyDictionary<string, string> ItemNames { get; }

			public ContainersConfig(ConfigFile cfg, string section)
			{
				ConfigFile cfg2 = cfg;
				string section2 = section;
				AutoSort = cfg2.BindEx(section2, defaultValue: false, "True to auto sort container inventories", "AutoSort");
				SortedMessageType = cfg2.BindEx(section2, MessageTypes.None, "Type of message to show when a container was sorted", (AcceptableValueBase?)(object)AcceptableEnum<MessageTypes>.Default, "SortedMessageType");
				AutoPickup = cfg2.BindEx(section2, defaultValue: false, "True to automatically put dropped items into containers if they already contain said item", "AutoPickup");
				AutoPickupRange = cfg2.BindEx(section2, 64f, "Required proximity of a container to a dropped item to be considered as auto pickup target. Can be overridden per chest by putting '\ud83e\uddf2<Range>' on a chest sign", "AutoPickupRange");
				AutoPickupMaxRange = cfg2