using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Text;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Valheim.ServersideQoL.CodeAnalysis")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a9d312ea750de985c0eb582dc4b190202d41f8af")]
[assembly: AssemblyProduct("Valheim.ServersideQoL.CodeAnalysis")]
[assembly: AssemblyTitle("Valheim.ServersideQoL.CodeAnalysis")]
[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]
	[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.CodeAnalysis
{
	[DiagnosticAnalyzer("C#", new string[] { })]
	public sealed class ExpressionCacheAnalyzer : DiagnosticAnalyzer
	{
		public const string DiagnosticId = "ARG0001";

		private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor("ARG0001", "Caller line not unique", "Each call to this method must be on its own line", "Usage", (DiagnosticSeverity)3, true, (string)null, (string)null, Array.Empty<string>());

		public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableCollectionsMarshal.AsImmutableArray<DiagnosticDescriptor>((DiagnosticDescriptor[])(object)new DiagnosticDescriptor[1] { Rule });


		public override void Initialize(AnalysisContext context)
		{
			context.EnableConcurrentExecution();
			context.ConfigureGeneratedCodeAnalysis((GeneratedCodeAnalysisFlags)0);
			context.RegisterSyntaxNodeAction<SyntaxKind>((Action<SyntaxNodeAnalysisContext>)delegate(SyntaxNodeAnalysisContext context)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Expected O, but got Unknown
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				MethodDeclarationSyntax val = (MethodDeclarationSyntax)((SyntaxNodeAnalysisContext)(ref context)).Node;
				HashSet<(ISymbol, int)> hashSet = null;
				foreach (InvocationExpressionSyntax item in ((SyntaxNode)val).DescendantNodes((Func<SyntaxNode, bool>)null, false).OfType<InvocationExpressionSyntax>())
				{
					SymbolInfo symbolInfo = CSharpExtensions.GetSymbolInfo(((SyntaxNodeAnalysisContext)(ref context)).SemanticModel, (ExpressionSyntax)(object)item, default(CancellationToken));
					ISymbol symbol = ((SymbolInfo)(ref symbolInfo)).Symbol;
					if (symbol != null && symbol.GetAttributes().Any(delegate(AttributeData x)
					{
						INamedTypeSymbol attributeClass = x.AttributeClass;
						return ((attributeClass != null) ? ((ISymbol)attributeClass).Name : null) == "MustBeOnUniqueLineAttribute";
					}))
					{
						Location location = ((CSharpSyntaxNode)item).GetLocation();
						FileLinePositionSpan lineSpan = location.GetLineSpan();
						HashSet<(ISymbol, int)> obj = hashSet ?? (hashSet = new HashSet<(ISymbol, int)>());
						LinePosition endLinePosition = ((FileLinePositionSpan)(ref lineSpan)).EndLinePosition;
						if (!obj.Add((symbol, ((LinePosition)(ref endLinePosition)).Line)))
						{
							((SyntaxNodeAnalysisContext)(ref context)).ReportDiagnostic(Diagnostic.Create(Rule, location, Array.Empty<object>()));
						}
					}
				}
			}, (SyntaxKind[])(object)new SyntaxKind[1] { (SyntaxKind)8875 });
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class MustBeOnUniqueLineAttribute : Attribute
	{
	}
	[DiagnosticAnalyzer("C#", new string[] { })]
	public sealed class ExpressionFactoryAnalyzer : DiagnosticAnalyzer
	{
		public const string DiagnosticId = "ARG0002";

		private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor("ARG0002", "Expression factories must be static", "Expression factories must be static", "Usage", (DiagnosticSeverity)3, true, (string)null, (string)null, Array.Empty<string>());

		private static readonly string __expressionTypeStartsWith = typeof(Expression).FullName + "<";

		public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableCollectionsMarshal.AsImmutableArray<DiagnosticDescriptor>((DiagnosticDescriptor[])(object)new DiagnosticDescriptor[1] { Rule });


		public override void Initialize(AnalysisContext context)
		{
			context.EnableConcurrentExecution();
			context.ConfigureGeneratedCodeAnalysis((GeneratedCodeAnalysisFlags)0);
			context.RegisterSyntaxNodeAction<SyntaxKind>((Action<SyntaxNodeAnalysisContext>)delegate(SyntaxNodeAnalysisContext context)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Expected O, but got Unknown
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				ParenthesizedLambdaExpressionSyntax val = (ParenthesizedLambdaExpressionSyntax)((SyntaxNodeAnalysisContext)(ref context)).Node;
				CSharpSyntaxNode body = ((AnonymousFunctionExpressionSyntax)val).Body;
				SimpleLambdaExpressionSyntax val2 = (SimpleLambdaExpressionSyntax)(object)((body is SimpleLambdaExpressionSyntax) ? body : null);
				if (val2 != null)
				{
					SymbolInfo symbolInfo = CSharpExtensions.GetSymbolInfo(((SyntaxNodeAnalysisContext)(ref context)).SemanticModel, (ExpressionSyntax)(object)val, default(CancellationToken));
					ISymbol symbol = ((SymbolInfo)(ref symbolInfo)).Symbol;
					IMethodSymbol val3 = (IMethodSymbol)(object)((symbol is IMethodSymbol) ? symbol : null);
					if (val3 != null && !symbol.IsStatic && ((ISymbol)val3.ReturnType).ToDisplayString((SymbolDisplayFormat)null).StartsWith(__expressionTypeStartsWith))
					{
						((SyntaxNodeAnalysisContext)(ref context)).ReportDiagnostic(Diagnostic.Create(Rule, ((CSharpSyntaxNode)val).GetLocation(), Array.Empty<object>()));
					}
				}
			}, (SyntaxKind[])(object)new SyntaxKind[1] { (SyntaxKind)8643 });
		}
	}
}

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Globalization;
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.CodeAnalysis;
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.5.2.0")]
[assembly: AssemblyInformationalVersion("1.5.2-beta.0.29+a9d312ea750de985c0eb582dc4b190202d41f8af")]
[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 ReadOnlyDictionary<TKey, TValue>
	{
		public static IReadOnlyDictionary<TKey, TValue> Empty { get; } = new System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue>(new Dictionary<TKey, TValue>(0));

	}
	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 sealed class ExtendedZDO : ZDO
	{
		private sealed class AdditionalData
		{
			[CompilerGenerated]
			private IReadOnlyList<Processor> <Processors>k__BackingField;

			private static readonly Dictionary<int, IReadOnlyList<Processor>> _processors = new Dictionary<int, IReadOnlyList<Processor>>();

			public bool HasProcessors { get; private set; } = true;


			public IReadOnlyList<Processor> Processors
			{
				get
				{
					return <Processors>k__BackingField ?? (<Processors>k__BackingField = Processor.DefaultProcessors);
				}
				private set
				{
					<Processors>k__BackingField = value;
					HasProcessors = value.Count > 0;
				}
			}

			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(IReadOnlyList<Processor> processors)
			{
				int num = 0;
				foreach (Processor item in Processors.AsEnumerable())
				{
					bool flag = true;
					foreach (Processor item2 in processors.AsEnumerable())
					{
						if (item == item2)
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						num = (num, item.GetType()).GetHashCode();
					}
				}
				if (!_processors.TryGetValue(num, out IReadOnlyList<Processor> value))
				{
					List<Processor> list = new List<Processor>();
					_processors.Add(num, value = list);
					foreach (Processor item3 in Processors.AsEnumerable())
					{
						bool flag2 = true;
						foreach (Processor item4 in processors.AsEnumerable())
						{
							if (item3 == item4)
							{
								flag2 = false;
								break;
							}
						}
						if (flag2)
						{
							list.Add(item3);
						}
					}
				}
				Processors = value;
				if (ProcessorDataRevisions == null)
				{
					return;
				}
				foreach (Processor item5 in processors.AsEnumerable())
				{
					ProcessorDataRevisions.Remove(item5);
				}
			}

			public void UnregisterAllExcept(Processor keep)
			{
				int hashCode = (0, keep.GetType()).GetHashCode();
				if (!_processors.TryGetValue(hashCode, out IReadOnlyList<Processor> value))
				{
					_processors.Add(hashCode, value = new <>z__ReadOnlySingleElementList<Processor>(keep));
				}
				if (ProcessorDataRevisions != null)
				{
					foreach (Processor item in Processors.AsEnumerable())
					{
						if (item != keep)
						{
							ProcessorDataRevisions.Remove(item);
						}
					}
				}
				Processors = value;
			}

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

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

		private sealed class UnityObjectEqualityComparer<T> : EqualityComparer<T> where T : Object
		{
			public static UnityObjectEqualityComparer<T> Instance { get; } = new UnityObjectEqualityComparer<T>();


			public override bool Equals(T x, T y)
			{
				object obj = x;
				string obj2 = ((obj != null) ? ((Object)obj).name : null);
				object obj3 = y;
				return obj2 == ((obj3 != null) ? ((Object)obj3).name : null);
			}

			public override int GetHashCode(T obj)
			{
				return ((Object)obj).name.GetHashCode();
			}
		}

		private delegate T GetHandler<T>(ZDO zdo, int hash, T defaultValue) where T : notnull;

		private delegate void SetHandler<T>(ZDO zdo, int hash, T value) where T : notnull;

		private delegate bool RemoveHandler<T>(ZDO zdo, int hash) where T : notnull;

		public sealed class ComponentFieldAccessor<TComponent>
		{
			private static class ExpressionCache<T> where T : notnull
			{
				private static readonly Dictionary<(string, int), Expression<Func<TComponent, T>>> __cache = new Dictionary<(string, int), Expression<Func<TComponent, T>>>();

				public static Expression<Func<TComponent, T>> Get(Func<Expression<Func<TComponent, T>>> factory, string callerFilePath, int callerLineNo)
				{
					if (!__cache.TryGetValue((callerFilePath, callerLineNo), out Expression<Func<TComponent, T>> value))
					{
						__cache.Add((callerFilePath, callerLineNo), value = factory());
					}
					return value;
				}
			}

			private sealed class FieldReference<T> where T : notnull
			{
				private readonly int _hash;

				private readonly Func<TComponent, T> _getFieldValue;

				private static readonly Dictionary<string, FieldReference<T>> __cacheByFieldName = new Dictionary<string, FieldReference<T>>();

				private static readonly Dictionary<(string, int), FieldReference<T>> __cacheByLocation = new Dictionary<(string, int), FieldReference<T>>();

				private static readonly (GetHandler<T> Getter, SetHandler<T> Setter, RemoveHandler<T>? Remover, IEqualityComparer<T> EqualityComparer) Accessors = ((Func<(GetHandler<T>, SetHandler<T>, RemoveHandler<T>, IEqualityComparer<T>)>)delegate
				{
					if (typeof(T) == typeof(bool))
					{
						return ((GetHandler<T>)(object)(GetHandler<bool>)((ZDO zdo, int hash, bool defaultValue) => zdo.GetBool(hash, defaultValue)), (SetHandler<T>)(object)(SetHandler<bool>)delegate(ZDO zdo, int hash, bool value)
						{
							zdo.Set(hash, value);
						}, (RemoveHandler<T>)(object)(RemoveHandler<bool>)((ZDO zdo, int hash) => zdo.RemoveInt(hash)), (IEqualityComparer<T>)EqualityComparer<bool>.Default);
					}
					if (typeof(T) == typeof(int))
					{
						return ((GetHandler<T>)(object)(GetHandler<int>)((ZDO zdo, int hash, int defaultValue) => zdo.GetInt(hash, defaultValue)), (SetHandler<T>)(object)(SetHandler<int>)delegate(ZDO zdo, int hash, int value)
						{
							zdo.Set(hash, value, false);
						}, (RemoveHandler<T>)(object)(RemoveHandler<int>)((ZDO zdo, int hash) => zdo.RemoveInt(hash)), (IEqualityComparer<T>)EqualityComparer<int>.Default);
					}
					if (typeof(T) == typeof(float))
					{
						return ((GetHandler<T>)(object)(GetHandler<float>)((ZDO zdo, int hash, float defaultValue) => zdo.GetFloat(hash, defaultValue)), (SetHandler<T>)(object)(SetHandler<float>)delegate(ZDO zdo, int hash, float value)
						{
							zdo.Set(hash, value);
						}, (RemoveHandler<T>)(object)(RemoveHandler<float>)((ZDO zdo, int hash) => zdo.RemoveFloat(hash)), (IEqualityComparer<T>)EqualityComparer<float>.Default);
					}
					if (typeof(T) == typeof(string))
					{
						return ((GetHandler<T>)(object)(GetHandler<string>)((ZDO zdo, int hash, string defaultValue) => zdo.GetString(hash, defaultValue)), (SetHandler<T>)(object)(SetHandler<string>)delegate(ZDO zdo, int hash, string value)
						{
							zdo.Set(hash, value);
						}, null, (IEqualityComparer<T>)EqualityComparer<string>.Default);
					}
					if (typeof(T) == typeof(Vector3))
					{
						return ((GetHandler<T>)(object)(GetHandler<Vector3>)((ZDO zdo, int hash, Vector3 defaultValue) => zdo.GetVec3(hash, defaultValue)), (SetHandler<T>)(object)(SetHandler<Vector3>)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);
						}, (RemoveHandler<T>)(object)(RemoveHandler<Vector3>)((ZDO zdo, int hash) => zdo.RemoveVec3(hash)), (IEqualityComparer<T>)EqualityComparer<Vector3>.Default);
					}
					if (typeof(T) == typeof(GameObject))
					{
						return ((GetHandler<T>)(object)new GetHandler<GameObject>(GetGameObject), (SetHandler<T>)(object)(SetHandler<GameObject>)delegate(ZDO zdo, int hash, GameObject value)
						{
							zdo.Set(hash, ((Object)value).name);
						}, null, (IEqualityComparer<T>)(object)UnityObjectEqualityComparer<GameObject>.Instance);
					}
					if (typeof(T) == typeof(ItemDrop))
					{
						return ((GetHandler<T>)(object)new GetHandler<ItemDrop>(GetItemDrop), (SetHandler<T>)(object)(SetHandler<ItemDrop>)delegate(ZDO zdo, int hash, ItemDrop value)
						{
							zdo.Set(hash, ((Object)value).name);
						}, null, (IEqualityComparer<T>)(object)UnityObjectEqualityComparer<ItemDrop>.Instance);
					}
					throw new NotSupportedException();
					static GameObject GetGameObject(ZDO zdo, int hash, GameObject defaultValue)
					{
						string string2 = zdo.GetString(hash, "");
						if (string.IsNullOrEmpty(string2))
						{
							return defaultValue;
						}
						return ZNetScene.instance.GetPrefab(string2) ?? defaultValue;
					}
					static ItemDrop GetItemDrop(ZDO zdo, int hash, ItemDrop defaultValue)
					{
						string @string = zdo.GetString(hash, "");
						if (!string.IsNullOrEmpty(@string))
						{
							GameObject prefab = ZNetScene.instance.GetPrefab(@string);
							return ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null) ?? defaultValue;
						}
						return defaultValue;
					}
				})();

				private FieldReference(FieldInfo field)
				{
					_hash = StringExtensionMethods.GetStableHashCode(FormattableString.Invariant($"{typeof(TComponent).Name}.{field.Name}"));
					ParameterExpression parameterExpression = Expression.Parameter(typeof(TComponent));
					_getFieldValue = Expression.Lambda<Func<TComponent, T>>(Expression.Field(parameterExpression, field), new ParameterExpression[1] { parameterExpression }).Compile();
				}

				public static FieldReference<T> Get(Func<Expression<Func<TComponent, T>>> factory, string callerFilePath, int callerLineNo)
				{
					if (!__cacheByLocation.TryGetValue((callerFilePath, callerLineNo), out FieldReference<T> value))
					{
						Expression<Func<TComponent, T>> expression = ExpressionCache<T>.Get(factory, callerFilePath, callerLineNo);
						MemberExpression memberExpression = (MemberExpression)expression.Body;
						FieldInfo fieldInfo = (FieldInfo)memberExpression.Member;
						if (!__cacheByFieldName.TryGetValue(fieldInfo.Name, out value))
						{
							__cacheByFieldName.Add(fieldInfo.Name, value = new FieldReference<T>(fieldInfo));
						}
						__cacheByLocation.Add((callerFilePath, callerLineNo), value);
					}
					return value;
				}

				public T GetValue(ComponentFieldAccessor<TComponent> componentFieldAccessor)
				{
					T val = _getFieldValue(componentFieldAccessor._component);
					if (!componentFieldAccessor.HasFields)
					{
						return val;
					}
					return Accessors.Getter((ZDO)(object)componentFieldAccessor._zdo, _hash, val);
				}

				public ComponentFieldAccessor<TComponent> SetValue(ComponentFieldAccessor<TComponent> componentFieldAccessor, T value)
				{
					if (Accessors.Remover != null && Accessors.EqualityComparer.Equals(value, _getFieldValue(componentFieldAccessor._component)))
					{
						Accessors.Remover((ZDO)(object)componentFieldAccessor._zdo, _hash);
					}
					else
					{
						if (!componentFieldAccessor.HasFields)
						{
							componentFieldAccessor.SetHasFields(value: true);
						}
						Accessors.Setter((ZDO)(object)componentFieldAccessor._zdo, _hash, value);
					}
					return componentFieldAccessor;
				}

				public bool UpdateValue(ComponentFieldAccessor<TComponent> componentFieldAccessor, T value)
				{
					T val = _getFieldValue(componentFieldAccessor._component);
					if (Accessors.EqualityComparer.Equals(value, Accessors.Getter((ZDO)(object)componentFieldAccessor._zdo, _hash, val)))
					{
						return false;
					}
					bool flag = Accessors.EqualityComparer.Equals(value, val);
					if (Accessors.Remover != null && flag)
					{
						Accessors.Remover((ZDO)(object)componentFieldAccessor._zdo, _hash);
					}
					else
					{
						if (!componentFieldAccessor.HasFields && !flag)
						{
							componentFieldAccessor.SetHasFields(value: true);
						}
						Accessors.Setter((ZDO)(object)componentFieldAccessor._zdo, _hash, value);
					}
					return true;
				}

				public ComponentFieldAccessor<TComponent> ResetValue(ComponentFieldAccessor<TComponent> componentFieldAccessor)
				{
					if (!componentFieldAccessor.HasFields)
					{
						return componentFieldAccessor;
					}
					if (Accessors.Remover != null)
					{
						Accessors.Remover((ZDO)(object)componentFieldAccessor._zdo, _hash);
					}
					else
					{
						Accessors.Setter((ZDO)(object)componentFieldAccessor._zdo, _hash, _getFieldValue(componentFieldAccessor._component));
					}
					return componentFieldAccessor;
				}

				public bool UpdateResetValue(ComponentFieldAccessor<TComponent> componentFieldAccessor)
				{
					if (!componentFieldAccessor.HasFields)
					{
						return false;
					}
					if (Accessors.Remover != null)
					{
						return Accessors.Remover((ZDO)(object)componentFieldAccessor._zdo, _hash);
					}
					T val = _getFieldValue(componentFieldAccessor._component);
					if (Accessors.EqualityComparer.Equals(Accessors.Getter((ZDO)(object)componentFieldAccessor._zdo, _hash, val), val))
					{
						return false;
					}
					Accessors.Setter((ZDO)(object)componentFieldAccessor._zdo, _hash, val);
					return true;
				}
			}

			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);
				}
			}

			[MustBeOnUniqueLine]
			public bool GetBool(Func<Expression<Func<TComponent, bool>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<bool>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).GetValue(this);
			}

			[MustBeOnUniqueLine]
			public float GetFloat(Func<Expression<Func<TComponent, float>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<float>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).GetValue(this);
			}

			[MustBeOnUniqueLine]
			public int GetInt(Func<Expression<Func<TComponent, int>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<int>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).GetValue(this);
			}

			[MustBeOnUniqueLine]
			public string GetString(Func<Expression<Func<TComponent, string>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<string>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).GetValue(this);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Set(Func<Expression<Func<TComponent, bool>>> fieldExpressionFactory, bool value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<bool>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).SetValue(this, value);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Set(Func<Expression<Func<TComponent, float>>> fieldExpressionFactory, float value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<float>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).SetValue(this, value);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Set(Func<Expression<Func<TComponent, int>>> fieldExpressionFactory, int value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<int>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).SetValue(this, value);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Set(Func<Expression<Func<TComponent, Vector3>>> fieldExpressionFactory, Vector3 value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return FieldReference<Vector3>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).SetValue(this, value);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Set(Func<Expression<Func<TComponent, string>>> fieldExpressionFactory, string value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<string>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).SetValue(this, value);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Set(Func<Expression<Func<TComponent, GameObject>>> fieldExpressionFactory, GameObject value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<GameObject>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).SetValue(this, value);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Set(Func<Expression<Func<TComponent, ItemDrop>>> fieldExpressionFactory, ItemDrop value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<ItemDrop>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).SetValue(this, value);
			}

			[MustBeOnUniqueLine]
			public bool UpdateValue(Func<Expression<Func<TComponent, bool>>> fieldExpressionFactory, bool value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<bool>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, value);
			}

			[MustBeOnUniqueLine]
			public bool UpdateValue(Func<Expression<Func<TComponent, float>>> fieldExpressionFactory, float value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<float>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, value);
			}

			[MustBeOnUniqueLine]
			public bool UpdateValue(Func<Expression<Func<TComponent, int>>> fieldExpressionFactory, int value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<int>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, value);
			}

			[MustBeOnUniqueLine]
			public bool UpdateValue(Func<Expression<Func<TComponent, string>>> fieldExpressionFactory, string value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<string>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, value);
			}

			[MustBeOnUniqueLine]
			public bool UpdateValue(Func<Expression<Func<TComponent, GameObject>>> fieldExpressionFactory, GameObject value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<GameObject>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, value);
			}

			[MustBeOnUniqueLine]
			public bool UpdateValue(Func<Expression<Func<TComponent, ItemDrop>>> fieldExpressionFactory, ItemDrop value, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<ItemDrop>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, value);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Reset(Func<Expression<Func<TComponent, bool>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<bool>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).ResetValue(this);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Reset(Func<Expression<Func<TComponent, float>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<float>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).ResetValue(this);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Reset(Func<Expression<Func<TComponent, int>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<int>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).ResetValue(this);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Reset(Func<Expression<Func<TComponent, string>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<string>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).ResetValue(this);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Reset(Func<Expression<Func<TComponent, GameObject>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<GameObject>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).ResetValue(this);
			}

			[MustBeOnUniqueLine]
			public ComponentFieldAccessor<TComponent> Reset(Func<Expression<Func<TComponent, ItemDrop>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<ItemDrop>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).ResetValue(this);
			}

			[MustBeOnUniqueLine]
			public bool UpdateResetValue(Func<Expression<Func<TComponent, bool>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<bool>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
			}

			[MustBeOnUniqueLine]
			public bool UpdateResetValue(Func<Expression<Func<TComponent, float>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<float>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
			}

			[MustBeOnUniqueLine]
			public bool UpdateResetValue(Func<Expression<Func<TComponent, int>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<int>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
			}

			[MustBeOnUniqueLine]
			public bool UpdateResetValue(Func<Expression<Func<TComponent, string>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<string>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
			}

			[MustBeOnUniqueLine]
			public bool UpdateResetValue(Func<Expression<Func<TComponent, GameObject>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<GameObject>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
			}

			[MustBeOnUniqueLine]
			public bool UpdateResetValue(Func<Expression<Func<TComponent, ItemDrop>>> fieldExpressionFactory, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				return FieldReference<ItemDrop>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
			}

			[MustBeOnUniqueLine]
			public bool SetOrReset(Func<Expression<Func<TComponent, bool>>> fieldExpressionFactory, bool set, bool setValue, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				if (!set)
				{
					return FieldReference<bool>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
				}
				return FieldReference<bool>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, setValue);
			}

			[MustBeOnUniqueLine]
			public bool SetOrReset(Func<Expression<Func<TComponent, float>>> fieldExpressionFactory, bool set, float setValue, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				if (!set)
				{
					return FieldReference<float>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
				}
				return FieldReference<float>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, setValue);
			}

			[MustBeOnUniqueLine]
			public bool SetOrReset(Func<Expression<Func<TComponent, int>>> fieldExpressionFactory, bool set, int setValue, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				if (!set)
				{
					return FieldReference<int>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
				}
				return FieldReference<int>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, setValue);
			}

			[MustBeOnUniqueLine]
			public bool SetOrReset(Func<Expression<Func<TComponent, string>>> fieldExpressionFactory, bool set, string setValue, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				if (!set)
				{
					return FieldReference<string>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
				}
				return FieldReference<string>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, setValue);
			}

			[MustBeOnUniqueLine]
			public bool SetOrReset(Func<Expression<Func<TComponent, GameObject>>> fieldExpressionFactory, bool set, GameObject setValue, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				if (!set)
				{
					return FieldReference<GameObject>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
				}
				return FieldReference<GameObject>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, setValue);
			}

			[MustBeOnUniqueLine]
			public bool SetOrReset(Func<Expression<Func<TComponent, ItemDrop>>> fieldExpressionFactory, bool set, ItemDrop setValue, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNo = -1)
			{
				if (!set)
				{
					return FieldReference<ItemDrop>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateResetValue(this);
				}
				return FieldReference<ItemDrop>.Get(fieldExpressionFactory, callerFilePath, callerLineNo).UpdateValue(this, setValue);
			}
		}

		public delegate void RecreateHandler(ExtendedZDO oldZdo, ExtendedZDO newZdo);

		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;
				}
			}

			public float TotalWeight => Inventory.GetTotalWeight();

			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_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Expected O, but got Unknown
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: 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(() => (Container x) => x.m_width, "D:\\a\\ValheimServersideQoL\\ValheimServersideQoL\\ValheimServersideQoL\\ExtendedZDO.ZDOInventory.cs", 47);
				int int2 = componentFieldAccessor.GetInt(() => (Container x) => x.m_height, "D:\\a\\ValheimServersideQoL\\ValheimServersideQoL\\ValheimServersideQoL\\ExtendedZDO.ZDOInventory.cs", 48);
				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);
					_items = null;
				}
				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.ZDOInventory.cs", 80);
				if (dataRevision != ((ZDO)ZDO).DataRevision)
				{
					(Container, PrefabInfo.Optional<Piece>, PrefabInfo.Optional<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;
			}
		}

		public readonly struct ZDOVars_
		{
			private readonly ExtendedZDO _zdo;

			private static int __processorId = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.ProcessorId");

			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");

			private static int __beaconFound = StringExtensionMethods.GetStableHashCode("argusmagnus.ServersideQoL.BeaconState");

			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 int GetLeftItem(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_leftItem, defaultValue);
			}

			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 string GetHealthString(string defaultValue = "")
			{
				return ((ZDO)_zdo).GetString(ZDOVars.s_health, defaultValue);
			}

			public void SetHealth(string 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 GetLocation(int defaultValue = 0)
			{
				return ((ZDO)_zdo).GetInt(ZDOVars.s_location, defaultValue);
			}

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

			public Guid GetProcessorId(Guid defaultValue = default(Guid))
			{
				byte[] byteArray = ((ZDO)_zdo).GetByteArray(__processorId, Array.Empty<byte>());
				if (byteArray == null || byteArray.Length <= 0)
				{
					return defaultValue;
				}
				return new Guid(byteArray);
			}

			public void SetProcessorId(Guid value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set(__processorId, (value == default(Guid)) ? Array.Empty<byte>() : value.ToByteArray());
			}

			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 GetBeaconFound(bool defaultValue = false)
			{
				return ((ZDO)_zdo).GetBool(__beaconFound, defaultValue);
			}

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

			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);
			}

			public float GetEstimatedSkillLevel(long playerID, SkillType skill, float defaultValue = 0f)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				return ((ZDO)_zdo).GetFloat($"player{playerID}_EstimatedSkillLevel_{skill}", defaultValue);
			}

			public void SetEstimatedSkillLevel(long playerID, SkillType skill, float value, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNo = 0)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				ValidateOwnership(filePath, lineNo);
				((ZDO)_zdo).Set($"player{playerID}_EstimatedSkillLevel_{skill}", value);
			}
		}

		private ZDOID _lastId = ZDOID.None;

		private AdditionalData? _addData;

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

		private static bool _onZdoDestroyedRegistered;

		[CompilerGenerated]
		private PlayerProcessor.IPeerInfo? <OwnerPeerInfo>k__BackingField;

		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 bool HasProcessors => AddData.HasProcessors;

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

		public DateTimeOffset OwnerTimestamp { get; private set; }

		public PlayerProcessor.IPeerInfo? OwnerPeerInfo
		{
			get
			{
				if (!((ZDO)this).HasOwner())
				{
					return null;
				}
				long owner = ((ZDO)this).GetOwner();
				PlayerProcessor.IPeerInfo? peerInfo = <OwnerPeerInfo>k__BackingField;
				if (peerInfo == null || peerInfo.Owner != owner)
				{
					<OwnerPeerInfo>k__BackingField = Processor.Instance<PlayerProcessor>().GetPeerInfo(owner);
				}
				return <OwnerPeerInfo>k__BackingField;
			}
		}

		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(IReadOnlyList<Processor> processors)
		{
			AddData.Ungregister(processors);
		}

		public void UnregisterAllExcept(Processor processor)
		{
			AddData.UnregisterAllExcept(processor);
		}

		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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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 extendedZDO = (ExtendedZDO)(object)ZDOMan.instance.CreateNewZDO(position, prefab);
			((ZDO)extendedZDO).Deserialize(new ZPackage(val.GetArray()));
			extendedZDO.SetOwnerInternal(owner);
			return extendedZDO;
		}

		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 interface IZDOInventoryReadOnly
	{
		IReadOnlyList<ItemData> Items { get; }

		float TotalWeight { get; }
	}
	internal interface IZDOInventory
	{
		Inventory Inventory { get; }

		IList<ItemData> Items { get; }

		float TotalWeight { get; }

		int? PickupRange { get; set; }

		int? FeedRange { get; set; }

		void Save();
	}
	internal static class ExtensionMethods
	{
		public readonly struct ListEnumerable<T>
		{
			public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable
			{
				private readonly IReadOnlyList<T> _list;

				private readonly int _count;

				private int _index;

				public T Current { get; private set; }

				readonly object? IEnumerator.Current => Current;

				public Enumerator(IReadOnlyList<T> list)
				{
					_list = list;
					_count = list.Count;
					_index = -1;
					Current = default(T);
				}

				public void Dispose()
				{
					Current = default(T);
				}

				public bool MoveNext()
				{
					if (++_index < _count)
					{
						Current = _list[_index];
						return true;
					}
					Current = default(T);
					return false;
				}

				public void Reset()
				{
					_index = -1;
				}
			}

			private readonly IReadOnlyList<T> _list;

			public ListEnumerable(IReadOnlyList<T> list)
			{
				_list = list;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_list);
			}
		}

		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
		{
		}

		public static void InsertSorted<T>(this List<T> list, T item) where T : IComparable<T>
		{
			int num = list.BinarySearch(item);
			if (num < 0)
			{
				num = ~num;
			}
			list.Insert(num, item);
		}

		public static ListEnumerable<T> AsEnumerable<T>(this IReadOnlyList<T> list)
		{
			return new ListEnumerable<T>(list);
		}

		public static IEnumerable<T> AsBoxedEnumerable<T>(this IReadOnlyList<T> list)
		{
			return Enumerable.AsEnumerable(list);
		}
	}
	[BepInPlugin("argusmagnus.ServersideQoL", "ServersideQoL", "1.5.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
		{
			public struct Enumerator : IEnumerator<Peer>, IEnumerator, IDisposable
			{
				private readonly PeersEnumerable _enumerable;

				private int _index;

				public Peer Current { get; private set; }

				readonly object IEnumerator.Current => Current;

				public Enumerator(PeersEnumerable enumerable)
				{
					Current = default(Peer);
					_enumerable = enumerable;
					_index = -2;
				}

				public void Dispose()
				{
					Current = default(Peer);
				}

				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				public bool MoveNext()
				{
					if (++_index < 0)
					{
						if (_enumerable._localPeer != null)
						{
							Current = new Peer(_enumerable._localPeer);
							return true;
						}
						_index++;
					}
					if (_index < _enumerable._peers.Count)
					{
						Current = new Peer(_enumerable._peers[_index]);
						return true;
					}
					Current = default(Peer);
					return false;
				}

				public void Reset()
				{
					_index = -2;
				}
			}

			private readonly ZNetPeer? _localPeer;

			private List<ZNetPeer> _peers;

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

			public PeersEnumerable(ZNetPeer? localPeer)
			{
				_localPeer = localPeer;
				_peers = new List<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();
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			IEnumerator<Peer> IEnumerable<Peer>.GetEnumerator()
			{
				return GetEnumerator();
			}

			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_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)
						{
							int num2 = (ZNet.instance.IsDedicated() ? 10 : 30);
							int num3 = ((Application.targetFrameRate < 0) ? (2 * num2) : Application.targetFrameRate);
							double num4 = 1.0 / (double)num2;
							double num5 = 1.0 / (double)Time.unscaledDeltaTime;
							if ((double)Time.unscaledDeltaTime > num4)
							{
								if (main.Config.General.DiagnosticLogs.Value)
								{
									main.Logger.LogInfo((object)$"No time budget available, actual FPS: {num5}, min FPS: {num2}, target FPS: {num3}");
								}
								break;
							}
							double num6 = Math.Min(1.0, (num5 - (double)num2) / (double)(num3 - num2));
							double timeBudgetSeconds = (num4 - (double)Time.unscaledDeltaTime) * num6;
							try
							{
								main.Execute(<peers>5__2, timeBudgetSeconds);
							}
							catch (OperationCanceledException)
							{
								return false;
							}
							catch (Exception ex2)
							{
								main.Logger.LogError((object)ex2);
								return false;
							}
							break;
						}
						<peers>5__2 = null;
						goto IL_005b;
					}
					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;
					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_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;
				}
				<>2__current = null;
				<>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 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 List<(Processor, double)>? _processingTimes;

		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.5.2";

		internal const string PluginInformationalVersion = "1.5.2-beta.0.29";

		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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
		}

		private void Awake()
		{
			Logger.LogWarning((object)"You are running a pre-release version: 1.5.2-beta.0.29");
			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.5.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, double timeBudgetSeconds)
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0916: Unknown result type (might be due to invalid IL or missing references)
			//IL_0996: Unknown result type (might be due to invalid IL or missing references)
			//IL_099a: Invalid comparison between Unknown and I4
			//IL_099c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0726: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a87: Unknown result type (might be due to invalid IL or missing references)
			double realtimeSinceStartupAsDouble = Time.realtimeSinceStartupAsDouble;
			double num = realtimeSinceStartupAsDouble + timeBudgetSeconds;
			_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> item in Config.GlobalsKeys.KeyConfigs.Where<KeyValuePair<GlobalKeys, ConfigEntryBase>>((KeyValuePair<GlobalKeys, ConfigEntryBase> x) => !object.Equals(x.Value.BoxedValue, x.Value.DefaultValue)))
					{
						item.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 num2;
						try
						{
							num2 = (float)Convert.ChangeType(val4.BoxedValue, typeof(float));
						}
						catch (Exception ex3)
						{
							Logger.LogError((object)ex3);
							continue;
						}
						ZoneSystem.instance.SetGlobalKey(val3, num2);
					}
				}
				foreach (Processor item2 in Processor.DefaultProcessors.AsEnumerable())
				{
					item2.Initialize(_executeCounter == 1);
				}
				if (_executeCounter == 1)
				{
					Config.ConfigFile.SettingChanged -= OnConfigChanged;
					Config.ConfigFile.SettingChanged += OnConfigChanged;
					return;
				}
				{
					foreach (ExtendedZDO @object in ZDOMan.instance.GetObjects())
					{
						@object.ReregisterAllProcessors();
					}
					return;
				}
			}
			peers.Update();
			SharedProcessorState.CleanUp(peers);
			if (peers.Count == 0)
			{
				return;
			}
			Dictionary<Vector2i, SectorInfo> playerSectorsOld = _playerSectorsOld;
			Dictionary<Vector2i, SectorInfo> playerSectors = _playerSectors;
			_playerSectors = playerSectorsOld;
			_playerSectorsOld = playerSectors;
			int value2 = Config.General.ZonesAroundPlayers.Value;
			Vector2i key2 = default(Vector2i);
			foreach (Peer peer in peers)
			{
				Vector2i zone = ZoneSystem.GetZone(peer.m_refPos);
				for (int i = zone.x - value2; i <= zone.x + value2; i++)
				{
					for (int j = zone.y - value2; j <= zone.y + value2; j++)
					{
						((Vector2i)(ref key2))..ctor(i, j);
						if (_playerSectorsOld.Remove(key2, out SectorInfo value3))
						{
							_playerSectors.Add(key2, value3);
							value3.InverseWeight = 0;
							value3.Peers.Clear();
							value3.Peers.Add(peer);
							continue;
						}
						if (_playerSectors.TryGetValue(key2, out value3))
						{
							value3.Peers.Add(peer);
							continue;
						}
						if (_sectorInfoPool.TryPop(out value3))
						{
							value3.Peers.Add(peer);
						}
						else
						{
							value3 = new SectorInfo(new List<Peer>(1) { peer }, new List<ZDO>());
						}
						_playerSectors.Add(key2, value3);
					}
				}
			}
			foreach (SectorInfo value4 in _playerSectorsOld.Values)
			{
				value4.InverseWeight = 0;
				value4.Peers.Clear();
				value4.ZDOs.Clear();
				_sectorInfoPool.Push(value4);
			}
			_playerSectorsOld.Clear();
			Dictionary<Vector2i, SectorInfo> playerSectors2 = _playerSectors;
			foreach (Processor item3 in Processor.DefaultProcessors.AsEnumerable())
			{
				item3.PreProcess(peers);
			}
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			foreach (var (val6, sectorInfo2) in playerSectors2)
			{
				if (Time.realtimeSinceStartupAsDouble > num)
				{
					break;
				}
				num3++;
				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);
					}
				}
				num5 += sectorInfo2.ZDOs.Count;
				while ((object)sectorInfo2 != null)
				{
					List<ZDO> zDOs = sectorInfo2.ZDOs;
					if (zDOs == null || zDOs.Count <= 0 || !(Time.realtimeSinceStartupAsDouble < num))
					{
						break;
					}
					num4++;
					ExtendedZDO extendedZDO2 = (ExtendedZDO)(object)sectorInfo2.ZDOs[sectorInfo2.ZDOs.Count - 1];
					sectorInfo2.ZDOs.RemoveAt(sectorInfo2.ZDOs.Count - 1);
					if (!((ZDO)extendedZDO2).IsValid() || !extendedZDO2.HasProcessors)
					{
						continue;
					}
					if (extendedZDO2.Processors.Count > 1)
					{
						Processor processor = null;
						foreach (Processor item4 in extendedZDO2.Processors.AsEnumerable())
						{
							if (item4.ClaimExclusive(extendedZDO2))
							{
								if (processor == null)
								{
									processor = item4;
								}
								else if (Config.General.DiagnosticLogs.Value)
								{
									Logger.LogError((object)FormattableString.Invariant($"ZDO {((ZDO)extendedZDO2).m_uid} claimed exclusive by {item4.GetType().Name} while already claimed by {processor.GetType().Name}"));
								}
							}
						}
						if (processor != null)
						{
							extendedZDO2.UnregisterAllExcept(processor);
						}
					}
					bool flag = false;
					bool flag2 = false;
					_unregister.Clear();
					foreach (Processor item5 in extendedZDO2.Processors.AsEnumerable())
					{
						if (extendedZDO2.CheckProcessorDataRevisionChanged(item5))
						{
							if (item5.Process(extendedZDO2, sectorInfo2.Peers))
							{
								extendedZDO2.UpdateProcessorDataRevision(item5);
							}
							if (item5.UnregisterZdoProcessor)
							{
								_unregister.Add(item5);
							}
							if (flag = item5.DestroyZdo)
							{
								extendedZDO2.Destroy();
								break;
							}
							flag2 = flag2 || item5.RecreateZdo;
						}
					}
					if (!flag && flag2)
					{
						extendedZDO2.Recreate();
					}
					else if (!flag && _unregister.Count > 0)
					{
						extendedZDO2.UnregisterProcessors(_unregister);
					}
				}
			}
			if (num3 < _playerSectors.Count || num4 < num5)
			{
				_unfinishedProcessingInRow++;
			}
			else
			{
				_unfinishedProcessingInRow = 0u;
			}
			if (!Config.General.DiagnosticLogs.Value)
			{
				return;
			}
			LogLevel val7 = (LogLevel)((_unfinishedProcessingInRow == 0) ? 32 : 16);
			double num6 = (Time.realtimeSinceStartupAsDouble - realtimeSinceStartupAsDouble) * 1000.0;
			Logger.Log(val7, (object)FormattableString.Invariant(FormattableStringFactory.Create("{0} took {1:F2} ms (budget: {2:F2} ms) to process {3}