using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using ServersideQoL.Processors;
using ServersideQoL.Utilities;
using UnityEngine;

[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("ArgusMagnus")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("ArgusMagnus")]
[assembly: AssemblyDescription("Automatically feeds processing stations such as smelters, kilns, windmills, shield generators, etc. from nearby containers")]
[assembly: AssemblyFileVersion("2.3.0.0")]
[assembly: AssemblyInformationalVersion("2.3.0+fa2d6368df524c9e10cfac8661269ed815ef1b12")]
[assembly: AssemblyProduct("ServersideQoL.AutoProcess")]
[assembly: AssemblyTitle("ServersideQoL.AutoProcess")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ArgusMagnus/ValheimServersideQoL")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Count;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Count;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Count;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyList(List<T> items)
	{
		_items = items;
	}

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

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

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

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return _items.Contains(item);
	}

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

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return _items.IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServersideQoL.AutoProcess
{
	[BepInPlugin("ArgusMagnus.ServersideQoL.AutoProcess", "ServersideQoL.AutoProcess", "2.3.0")]
	public sealed class AutoProcessPlugin : ServersideQoLPluginBase<AutoProcessPlugin, Config>
	{
		public const string Author = "ArgusMagnus";

		public const string PluginName = "ServersideQoL.AutoProcess";

		public const string PluginGuid = "ArgusMagnus.ServersideQoL.AutoProcess";

		public const string PluginVersion = "2.3.0";

		public const string PluginInformationalVersion = "2.3.0";

		private DateTimeOffset BuildTimestamp { get; } = new DateTimeOffset(639273812576652814L, default(TimeSpan));

		protected override Config CreateConfigSingleton(ConfigFile configFile, Logger logger)
		{
			return new Config(configFile, logger);
		}

		protected override void RegisterProcessors(IProcessorCollection processors)
		{
			processors.Add<SmelterProcessor>().Add<FermenterProcessor>();
		}

		private void Awake()
		{
		}
	}
	public sealed class Config : ConfigBase<Config>
	{
		public sealed class LocalizationConfig
		{
			private string FuelAdded { get; init; } = "{0}: $msg_added {1} {2}x";

			private string OreAdded { get; init; } = "{0}: $msg_added {1} {2}x";

			public string FormatFuelAdded(string smelterName, string itemName, int stack)
			{
				return string.Format(FuelAdded, smelterName, itemName, stack);
			}

			public string FormatOreAdded(string smelterName, string itemName, int stack)
			{
				return string.Format(OreAdded, smelterName, itemName, stack);
			}
		}

		private const string DefaultRangeEmoji = "↔\ufe0f";

		public override ConfigEntry<bool> Enabled { get; } = ConfigBase<Config>.BindEx<bool>(cfg, true, "Enables/disables the entire mod", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "Enabled");

		public ConfigEntry<bool> FeedFromContainers { get; } = Shared.AutoProcessFeedFromContainers = ConfigBase<Config>.BindEx<bool>(cfg, true, "True to automatically feed smelters from nearby containers", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "FeedFromContainers");

		public ConfigEntry<bool> FeedFermenters { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, "True to automatically add fermentable items (e.g. mead bases) to empty fermenters from nearby containers. Requires FeedFromContainers", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "FeedFermenters");

		public ConfigEntry<bool> TapFermenters { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, "True to automatically tap fermenters when the content is ready. The products (e.g. mead) are dropped like when tapping by hand, use AutoStore to put them into containers", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "TapFermenters");

		public ConfigEntry<float> FeedFromContainersRange { get; } = ConfigBase<Config>.BindEx<float>(cfg, 4f, "Required proximity of a container to a smelter to be used as feeding source.\r\nCan be overridden per chest by putting '<FeedFromContainersRangeSignPrefix><Range>' on a chest sign, e.g. '↔\ufe0f64'.\r\n  For example, '↔\ufe0f64' increase the range of that chest to 64m.\r\n  Only works with automatic chest signs added by the ServersideQoL.ContainerSigns mod.", (IAcceptableValueBase<float>)null, (Deprecated<Config>)null, "FeedFromContainersRange");

		public ConfigEntry<string> FeedFromContainersRangeSignPrefix { get; } = Shared.AutoProcessFeedFromContainersRangeSignPrefix = ConfigBase<Config>.BindEx<string>(cfg, "↔\ufe0f", "Requires the ServersideQoL.ContainerSigns mod.\r\nThe prefix used to identify the container specifc feed range value in chest sign text.", (IAcceptableValueBase<string>)null, (Deprecated<Config>)null, "FeedFromContainersRangeSignPrefix");

		public ConfigEntry<int> FeedFromContainersMaxRange { get; } = Shared.AutoProcessFeedFromContainersMaxRange = ConfigBase<Config>.BindEx<int>(cfg, 64, "Requires the ServersideQoL.ContainerSigns mod.\r\nMax feeding range players can set per chest (by putting '<FeedFromContainersRangeSignPrefix><Range>' on a chest sign)", (IAcceptableValueBase<int>)null, (Deprecated<Config>)null, "FeedFromContainersMaxRange");

		public ConfigEntry<float> FeedFromContainersMinPlayerDistance { get; } = ConfigBase<Config>.BindEx<float>(cfg, 4f, "Min distance all players must have to a processing station", (IAcceptableValueBase<float>)null, (Deprecated<Config>)null, "FeedFromContainersMinPlayerDistance");

		public ConfigEntry<ConfigArray<string>> FeedFromContainersExcludeContainers { get; }

		public ConfigEntry<int> FeedFromContainersLeaveAtLeastFuel { get; }

		public ConfigEntry<int> FeedFromContainersLeaveAtLeastOre { get; }

		public ConfigEntry<int> FeedFromContainersLeaveAtLeastFermentable { get; }

		public ConfigEntry<MessageTypes> OreOrFuelAddedMessageType { get; }

		public ConfigEntry<float> CapacityMultiplier { get; }

		public ConfigEntry<float> TimePerProductMultiplier { get; }

		public YamlConfigEntry<LocalizationConfig> Localization { get; }

		public Config(ConfigFile cfg, Logger logger)
		{
			ConfigArray<string> obj = new ConfigArray<string>((IReadOnlyList<string>)Array.Empty<string>());
			List<string> list = new List<string>();
			list.AddRange(ConfigBase.PlaceableContainers.Select((PlaceableContainer x) => x.Name));
			FeedFromContainersExcludeContainers = ConfigBase<Config>.BindEx<ConfigArray<string>>(cfg, obj, "", (IAcceptableValueBase<ConfigArray<string>>)(object)AcceptableArrayValues.Get<string>((IReadOnlyList<string>)new <>z__ReadOnlyList<string>(list)), (Deprecated<Config>)null, "FeedFromContainersExcludeContainers");
			FeedFromContainersLeaveAtLeastFuel = ConfigBase<Config>.BindEx<int>(cfg, 1, "Minimum amount of fuel to leave in a container", (IAcceptableValueBase<int>)null, (Deprecated<Config>)null, "FeedFromContainersLeaveAtLeastFuel");
			FeedFromContainersLeaveAtLeastOre = ConfigBase<Config>.BindEx<int>(cfg, 1, "Minimum amount of ore to leave in a container", (IAcceptableValueBase<int>)null, (Deprecated<Config>)null, "FeedFromContainersLeaveAtLeastOre");
			FeedFromContainersLeaveAtLeastFermentable = ConfigBase<Config>.BindEx<int>(cfg, 0, "Minimum amount of fermentable items (e.g. mead bases) to leave in a container", (IAcceptableValueBase<int>)null, (Deprecated<Config>)null, "FeedFromContainersLeaveAtLeastFermentable");
			OreOrFuelAddedMessageType = ConfigBase<Config>.BindEx<MessageTypes>(cfg, (MessageTypes)0, "Type of message to show when ore or fuel is added to a smelter", (IAcceptableValueBase<MessageTypes>)(object)AcceptableEnum<MessageTypes>.Default, (Deprecated<Config>)null, "OreOrFuelAddedMessageType");
			CapacityMultiplier = ConfigBase<Config>.BindEx<float>(cfg, 1f, "Multiply a smelter's ore/fuel capacity by this factor", (IAcceptableValueBase<float>)null, (Deprecated<Config>)null, "CapacityMultiplier");
			TimePerProductMultiplier = ConfigBase<Config>.BindEx<float>(cfg, 1f, "Multiply the time it takes to produce one product by this factor (will not go below 1 second per product).", (IAcceptableValueBase<float>)null, (Deprecated<Config>)null, "TimePerProductMultiplier");
			Localization = ConfigBase<Config>.BindYaml<LocalizationConfig>(cfg, "Localization");
			base..ctor(cfg, logger);
		}
	}
	[Processor("4d9ff5be-1a2e-469e-8046-addadfd58bab")]
	[RunAfter<ContainerRegistryProcessor>]
	public sealed class FermenterProcessor : Processor<FermenterProcessor.PrefabInfo>
	{
		public sealed record PrefabInfo(Fermenter Fermenter) : ProcessorPrefabInfo()
		{
			[CompilerGenerated]
			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("PrefabInfo");
				stringBuilder.Append(" { ");
				if (((ProcessorPrefabInfo)this).PrintMembers(stringBuilder))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append('}');
				return stringBuilder.ToString();
			}

			[CompilerGenerated]
			protected override bool PrintMembers(StringBuilder builder)
			{
				if (((ProcessorPrefabInfo)this).PrintMembers(builder))
				{
					builder.Append(", ");
				}
				builder.Append("Fermenter = ");
				builder.Append(Fermenter);
				return true;
			}

			[CompilerGenerated]
			public override int GetHashCode()
			{
				return ((ProcessorPrefabInfo)this).GetHashCode() * -1521134295 + EqualityComparer<Fermenter>.Default.GetHashCode(Fermenter);
			}

			[CompilerGenerated]
			public sealed override bool Equals(ProcessorPrefabInfo? other)
			{
				return ((object)this).Equals((object?)other);
			}

			[CompilerGenerated]
			public bool Equals(PrefabInfo? other)
			{
				if ((object)this != other)
				{
					if (((ProcessorPrefabInfo)this).Equals((ProcessorPrefabInfo)(object)other))
					{
						return EqualityComparer<Fermenter>.Default.Equals(Fermenter, other.Fermenter);
					}
					return false;
				}
				return true;
			}

			[CompilerGenerated]
			private PrefabInfo(PrefabInfo original)
				: base((ProcessorPrefabInfo)(object)original)
			{
				Fermenter = original.Fermenter;
			}
		}

		public const string Id = "4d9ff5be-1a2e-469e-8046-addadfd58bab";

		private const float TapRetryDelay = 10f;

		private SectorDictionary<HashSet<ServersideQoLZDO>>? _fermenters;

		private SectorDictionary<SharedItemDataKey, HashSet<ServersideQoLZDO>>? _containersByItemName;

		protected override void Initialize()
		{
			Processor.Instance<ContainerRegistryProcessor>().ContainerChanged -= OnContainerChanged;
			if (ConfigBase<Config>.Instance.FeedFromContainers.Value && ConfigBase<Config>.Instance.FeedFermenters.Value)
			{
				_fermenters = new SectorDictionary<HashSet<ServersideQoLZDO>>(Mathf.Max(ConfigBase<Config>.Instance.FeedFromContainersRange.Value, (float)ConfigBase<Config>.Instance.FeedFromContainersMaxRange.Value));
				_containersByItemName = Processor.Instance<ContainerRegistryProcessor>().GetContainersByItemName(_fermenters.SectorWidth);
				Processor.Instance<ContainerRegistryProcessor>().ContainerChanged += OnContainerChanged;
			}
			else
			{
				_fermenters = null;
				_containersByItemName = null;
			}
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			ZDOVars vars = zdo.Vars;
			PlayerID val = default(PlayerID);
			val = ((ZDOVars)(ref vars)).GetCreator(val);
			if (((PlayerID)(ref val)).Value == 0L)
			{
				return (ProcessResult)2;
			}
			if (_fermenters == null && !ConfigBase<Config>.Instance.TapFermenters.Value)
			{
				return (ProcessResult)2;
			}
			SectorDictionary<HashSet<ServersideQoLZDO>>? fermenters = _fermenters;
			if (fermenters != null)
			{
				SectorDictionary.TryAdd(fermenters, zdo, true);
			}
			if (!Processor.CheckMinDistance(peers, zdo, ConfigBase<Config>.Instance.FeedFromContainersMinPlayerDistance.Value))
			{
				return ((Processor)this).ScheduleReprocessing(0f);
			}
			vars = zdo.Vars;
			if (((ZDOVars)(ref vars)).GetContent(0) == 0)
			{
				if (_fermenters == null)
				{
					return (ProcessResult)0;
				}
				return Feed(zdo, peers, prefabInfo);
			}
			if (!ConfigBase<Config>.Instance.TapFermenters.Value)
			{
				return (ProcessResult)0;
			}
			return Tap(zdo);
		}

		private ProcessResult Feed(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			ProcessResult val = (ProcessResult)0;
			bool flag = false;
			List<ServersideQoLZDO> list = null;
			foreach (ItemConversion item in prefabInfo.Fermenter.m_conversion)
			{
				ItemData baseItem = item.m_from.m_itemData;
				AdjacentEnumerator<SharedItemDataKey, HashSet<ServersideQoLZDO>> enumerator2 = _containersByItemName.EnumerateAdjacent((zdo.ZDO.GetPosition(), SharedItemDataKey.op_Implicit(baseItem.m_shared))).GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						HashSet<ServersideQoLZDO> current2 = enumerator2.Current;
						list?.Clear();
						foreach (ServersideQoLZDO item2 in current2)
						{
							if (Processor.Instance<SmelterProcessor>().ExcludedContainers.Contains(item2.ZDO.GetPrefab()))
							{
								continue;
							}
							ContainerState state = Processor.Instance<ContainerRegistryProcessor>().GetState(item2);
							if (state == null)
							{
								(list ?? (list = new List<ServersideQoLZDO>())).Add(item2);
								continue;
							}
							ZDOVars vars = item2.Vars;
							if (((ZDOVars)(ref vars)).GetInUse(false))
							{
								continue;
							}
							float num = state.AutoProcessFeedRange ?? ConfigBase<Config>.Instance.FeedFromContainersRange.Value;
							num *= num;
							if (num == 0f || Utils.DistanceSqr(zdo.ZDO.GetPosition(), item2.ZDO.GetPosition()) > num)
							{
								continue;
							}
							IInventory inventory = state.GetInventory();
							int num2 = ConfigBase<Config>.Instance.FeedFromContainersLeaveAtLeastFermentable.Value;
							ItemData val2 = null;
							bool flag2 = false;
							foreach (ItemData item3 in from x in inventory.Items
								where new ItemDataKey(x) == ItemDataKey.op_Implicit(baseItem)
								orderby x.m_stack
								select x)
							{
								flag2 = flag2 || (item3 != null && item3.m_stack > 0);
								int num3 = Math.Min(item3.m_stack, num2);
								num2 -= num3;
								if (item3.m_stack > num3)
								{
									val2 = item3;
									break;
								}
							}
							if (val2 == null)
							{
								if (!flag2)
								{
									(list ?? (list = new List<ServersideQoLZDO>())).Add(item2);
								}
								continue;
							}
							if (!item2.IsOwnerOrUnassigned())
							{
								val |= ((Processor)this).ScheduleReprocessing(Processor.Instance<ContainerRegistryProcessor>().RequestOwnership(item2, default(PlayerID)));
								continue;
							}
							ItemData obj = val2;
							obj.m_stack--;
							if (val2.m_stack == 0)
							{
								inventory.Items.Remove(val2);
								List<ItemData> items = inventory.Items;
								if (items != null && items.Count == 0)
								{
									(list ?? (list = new List<ServersideQoLZDO>())).Add(item2);
								}
							}
							zdo.ReleaseOwnership();
							vars = zdo.Vars;
							((ZDOVars)(ref vars)).SetContent(StringExtensionMethods.GetStableHashCode(((Object)((Component)item.m_from).gameObject).name), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\FermenterProcessor.cs", 125);
							vars = zdo.Vars;
							((ZDOVars)(ref vars)).SetStartTime(ZNet.instance.GetTime(), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\FermenterProcessor.cs", 126);
							inventory.Save();
							Processor.ShowMessage((IEnumerable<Peer>)peers, zdo, ConfigBase<Config>.Instance.Localization.Value.FormatOreAdded(prefabInfo.Fermenter.m_name, baseItem.m_shared.m_name, 1), ConfigBase<Config>.Instance.OreOrFuelAddedMessageType.Value, (TextType)0);
							flag = true;
							break;
						}
						if (list != null)
						{
							foreach (ServersideQoLZDO item4 in list)
							{
								current2.Remove(item4);
							}
						}
						if (flag)
						{
							break;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
				if (flag)
				{
					break;
				}
			}
			return val;
		}

		private ProcessResult Tap(ServersideQoLZDO zdo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			ZDOVars vars = zdo.Vars;
			DateTime startTime = ((ZDOVars)(ref vars)).GetStartTime(default(DateTime));
			if (startTime.Ticks == 0L)
			{
				return (ProcessResult)0;
			}
			float num = zdo.Fields<Fermenter>().GetFloat((Func<Expression<Func<Fermenter, float>>>)(() => (Fermenter x) => x.m_fermentationDuration), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\FermenterProcessor.cs", 161) - (float)(ZNet.instance.GetTime() - startTime).TotalSeconds;
			if (num >= 0f)
			{
				return ((Processor)this).ScheduleReprocessing(num + 1f);
			}
			if (!zdo.IsOwnerOrUnassigned())
			{
				ZDORpc rPC = zdo.RPC;
				FermenterRpc fermenter = ((ZDORpc)(ref rPC)).Fermenter;
				((FermenterRpc)(ref fermenter)).Tap();
			}
			return ((Processor)this).ScheduleReprocessing(10f);
		}

		private void OnContainerChanged(ServersideQoLZDO containerZdo, ContainerState state)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (_fermenters == null)
			{
				Processor.Instance<ContainerRegistryProcessor>().ContainerChanged -= OnContainerChanged;
			}
			else
			{
				if (Processor.Instance<SmelterProcessor>().ExcludedContainers.Contains(containerZdo.ZDO.GetPrefab()))
				{
					return;
				}
				float num = state.AutoProcessFeedRange ?? ConfigBase<Config>.Instance.FeedFromContainersRange.Value;
				num *= num;
				if (num == 0f)
				{
					return;
				}
				AdjacentEnumerator<HashSet<ServersideQoLZDO>> enumerator = _fermenters.EnumerateAdjacent(containerZdo.ZDO.GetPosition()).GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						HashSet<ServersideQoLZDO> current = enumerator.Current;
						foreach (ServersideQoLZDO item in current)
						{
							if (Utils.DistanceSqr(item.ZDO.GetPosition(), containerZdo.ZDO.GetPosition()) <= num)
							{
								((Processor)this).ScheduleReprocessing(item, 0f);
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}
	}
	[Processor("1db73d4d-e930-402f-933e-cb92e5748312")]
	[RunAfter<ContainerRegistryProcessor>]
	public sealed class SmelterProcessor : Processor<SmelterProcessor.PrefabInfo>
	{
		public sealed record PrefabInfo(Smelter? Smelter, ShieldGenerator? ShieldGenerator) : ProcessorPrefabInfo()
		{
			[MemberNotNullWhen(true, "Smelter")]
			public bool HasProduct
			{
				[MemberNotNullWhen(true, "Smelter")]
				get;
			} = Smelter?.m_conversion.Any((ItemConversion x) => x.m_to != null) ?? false;

			[CompilerGenerated]
			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("PrefabInfo");
				stringBuilder.Append(" { ");
				if (((ProcessorPrefabInfo)this).PrintMembers(stringBuilder))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append('}');
				return stringBuilder.ToString();
			}

			[CompilerGenerated]
			protected override bool PrintMembers(StringBuilder builder)
			{
				if (((ProcessorPrefabInfo)this).PrintMembers(builder))
				{
					builder.Append(", ");
				}
				builder.Append("Smelter = ");
				builder.Append(Smelter);
				builder.Append(", ShieldGenerator = ");
				builder.Append(ShieldGenerator);
				builder.Append(", HasProduct = ");
				builder.Append(HasProduct.ToString());
				return true;
			}

			[CompilerGenerated]
			public override int GetHashCode()
			{
				return ((((ProcessorPrefabInfo)this).GetHashCode() * -1521134295 + EqualityComparer<Smelter>.Default.GetHashCode(Smelter)) * -1521134295 + EqualityComparer<ShieldGenerator>.Default.GetHashCode(ShieldGenerator)) * -1521134295 + EqualityComparer<bool>.Default.GetHashCode(HasProduct);
			}

			[CompilerGenerated]
			public sealed override bool Equals(ProcessorPrefabInfo? other)
			{
				return ((object)this).Equals((object?)other);
			}

			[CompilerGenerated]
			public bool Equals(PrefabInfo? other)
			{
				if ((object)this != other)
				{
					if (((ProcessorPrefabInfo)this).Equals((ProcessorPrefabInfo)(object)other) && EqualityComparer<Smelter>.Default.Equals(Smelter, other.Smelter) && EqualityComparer<ShieldGenerator>.Default.Equals(ShieldGenerator, other.ShieldGenerator))
					{
						return EqualityComparer<bool>.Default.Equals(HasProduct, other.HasProduct);
					}
					return false;
				}
				return true;
			}

			[CompilerGenerated]
			private PrefabInfo(PrefabInfo original)
				: base((ProcessorPrefabInfo)(object)original)
			{
				Smelter = original.Smelter;
				ShieldGenerator = original.ShieldGenerator;
				HasProduct = original.HasProduct;
			}
		}

		private SectorDictionary<HashSet<ServersideQoLZDO>>? _smelters;

		private SectorDictionary<SharedItemDataKey, HashSet<ServersideQoLZDO>>? _containersByItemName;

		internal HashSet<int> ExcludedContainers { get; private set; } = new HashSet<int>();

		protected override void Initialize()
		{
			ExcludedContainers.Clear();
			Processor.Instance<ContainerRegistryProcessor>().ContainerChanged -= OnContainerChanged;
			if (ConfigBase<Config>.Instance.FeedFromContainers.Value)
			{
				HashSet<int> hashSet = new HashSet<int>();
				foreach (int item in ConfigBase<Config>.Instance.FeedFromContainersExcludeContainers.Value.Items.Select((string x) => StringExtensionMethods.GetStableHashCode(x)))
				{
					hashSet.Add(item);
				}
				ExcludedContainers = hashSet;
				_smelters = new SectorDictionary<HashSet<ServersideQoLZDO>>(Mathf.Max(ConfigBase<Config>.Instance.FeedFromContainersRange.Value, (float)ConfigBase<Config>.Instance.FeedFromContainersMaxRange.Value));
				_containersByItemName = Processor.Instance<ContainerRegistryProcessor>().GetContainersByItemName(_smelters.SectorWidth);
				Processor.Instance<ContainerRegistryProcessor>().ContainerChanged += OnContainerChanged;
			}
			else
			{
				_smelters = null;
				_containersByItemName = null;
			}
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_086a: Unknown result type (might be due to invalid IL or missing references)
			//IL_086f: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d22: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0977: Unknown result type (might be due to invalid IL or missing references)
			//IL_097c: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b41: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b47: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b53: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b54: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0645: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_0658: Unknown result type (might be due to invalid IL or missing references)
			//IL_0700: Unknown result type (might be due to invalid IL or missing references)
			//IL_0705: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bf9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c40: Unknown result type (might be due to invalid IL or missing references)
			ProcessResult val = (ProcessResult)0;
			if (ConfigBase<Config>.Instance.CapacityMultiplier.Value == 1f)
			{
				if (prefabInfo.Smelter != null)
				{
					zdo.Fields<Smelter>().Reset((Func<Expression<Func<Smelter, int>>>)(() => (Smelter x) => x.m_maxFuel), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 50).Reset((Func<Expression<Func<Smelter, int>>>)(() => (Smelter x) => x.m_maxOre), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 51);
				}
				else
				{
					zdo.Fields<ShieldGenerator>().Reset((Func<Expression<Func<ShieldGenerator, int>>>)(() => (ShieldGenerator x) => x.m_maxFuel), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 54);
				}
			}
			else if (prefabInfo.ShieldGenerator != null)
			{
				if (zdo.Fields<ShieldGenerator>().UpdateValue((Func<Expression<Func<ShieldGenerator, int>>>)(() => (ShieldGenerator x) => x.m_maxFuel), Mathf.RoundToInt(ConfigBase<Config>.Instance.CapacityMultiplier.Value * (float)prefabInfo.ShieldGenerator.m_maxFuel), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 60))
				{
					val = (ProcessResult)8;
				}
			}
			else if (prefabInfo.Smelter != null)
			{
				if (zdo.Fields<Smelter>().UpdateValue((Func<Expression<Func<Smelter, int>>>)(() => (Smelter x) => x.m_maxFuel), Mathf.RoundToInt(ConfigBase<Config>.Instance.CapacityMultiplier.Value * (float)prefabInfo.Smelter.m_maxFuel), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 65))
				{
					val = (ProcessResult)8;
				}
				if (zdo.Fields<Smelter>().UpdateValue((Func<Expression<Func<Smelter, int>>>)(() => (Smelter x) => x.m_maxOre), Mathf.RoundToInt(ConfigBase<Config>.Instance.CapacityMultiplier.Value * (float)prefabInfo.Smelter.m_maxOre), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 67))
				{
					val = (ProcessResult)8;
				}
			}
			if (prefabInfo.HasProduct)
			{
				if (ConfigBase<Config>.Instance.TimePerProductMultiplier.Value == 1f)
				{
					zdo.Fields<Smelter>().Reset((Func<Expression<Func<Smelter, float>>>)(() => (Smelter x) => x.m_secPerProduct), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 75);
				}
				else if (zdo.Fields<Smelter>().UpdateValue((Func<Expression<Func<Smelter, float>>>)(() => (Smelter x) => x.m_secPerProduct), Mathf.Max(1f, prefabInfo.Smelter.m_secPerProduct * ConfigBase<Config>.Instance.TimePerProductMultiplier.Value), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 76))
				{
					val = (ProcessResult)8;
				}
			}
			if (_smelters == null || _containersByItemName == null)
			{
				return (ProcessResult)(val | 2);
			}
			if (!Processor.CheckMinDistance(peers, zdo, ConfigBase<Config>.Instance.FeedFromContainersMinPlayerDistance.Value))
			{
				return (ProcessResult)(val | ((Processor)this).ScheduleReprocessing(0f));
			}
			List<ServersideQoLZDO> list = null;
			List<ItemData> list2 = null;
			int num = ((prefabInfo.Smelter != null) ? zdo.Fields<Smelter>().GetInt((Func<Expression<Func<Smelter, int>>>)(() => (Smelter x) => x.m_maxFuel), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 92) : zdo.Fields<ShieldGenerator>().GetInt((Func<Expression<Func<ShieldGenerator, int>>>)(() => (ShieldGenerator x) => x.m_maxFuel), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 93));
			ZDOVars vars = zdo.Vars;
			float num2 = ((ZDOVars)(ref vars)).GetFuel(0f);
			int num3 = (int)((float)num - num2);
			if (num3 > num / 2)
			{
				foreach (ItemData fuelItem in prefabInfo.ShieldGenerator?.m_fuelItems.Select((ItemDrop x) => x.m_itemData) ?? new <>z__ReadOnlySingleElementList<ItemData>(prefabInfo.Smelter.m_fuelItem.m_itemData))
				{
					int num4 = 0;
					AdjacentEnumerator<SharedItemDataKey, HashSet<ServersideQoLZDO>> enumerator2 = _containersByItemName.EnumerateAdjacent((zdo.ZDO.GetPosition(), SharedItemDataKey.op_Implicit(fuelItem.m_shared))).GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							HashSet<ServersideQoLZDO> current = enumerator2.Current;
							list?.Clear();
							foreach (ServersideQoLZDO item in current)
							{
								if (ExcludedContainers.Contains(item.ZDO.GetPrefab()))
								{
									continue;
								}
								ContainerState state = Processor.Instance<ContainerRegistryProcessor>().GetState(item);
								if (state == null)
								{
									(list ?? (list = new List<ServersideQoLZDO>())).Add(item);
									continue;
								}
								vars = item.Vars;
								if (((ZDOVars)(ref vars)).GetInUse(false))
								{
									continue;
								}
								float num5 = state.AutoProcessFeedRange ?? ConfigBase<Config>.Instance.FeedFromContainersRange.Value;
								num5 *= num5;
								if (num5 == 0f || Utils.DistanceSqr(zdo.ZDO.GetPosition(), item.ZDO.GetPosition()) > num5)
								{
									continue;
								}
								IInventory inventory = state.GetInventory();
								list2?.Clear();
								int num6 = 0;
								int num7 = ConfigBase<Config>.Instance.FeedFromContainersLeaveAtLeastFuel.Value;
								bool flag = false;
								bool flag2 = false;
								foreach (ItemData item2 in from x in inventory.Items
									where new ItemDataKey(x) == ItemDataKey.op_Implicit(fuelItem)
									orderby x.m_stack
									select x)
								{
									flag = flag || (item2 != null && item2.m_stack > 0);
									int num8 = Math.Min(item2.m_stack, num7);
									int num9 = Math.Min(num3, item2.m_stack - num8);
									num7 -= num8;
									if (num9 != 0)
									{
										if (!item.IsOwnerOrUnassigned())
										{
											flag2 = true;
											break;
										}
										num6 += num9;
										item2.m_stack -= num9;
										if (item2.m_stack == 0)
										{
											(list2 ?? (list2 = new List<ItemData>())).Add(item2);
										}
										num3 -= num9;
										if (num3 == 0)
										{
											break;
										}
									}
								}
								if (flag2)
								{
									val |= ((Processor)this).ScheduleReprocessing(Processor.Instance<ContainerRegistryProcessor>().RequestOwnership(item, default(PlayerID)));
									continue;
								}
								if (num6 == 0)
								{
									if (!flag)
									{
										(list ?? (list = new List<ServersideQoLZDO>())).Add(item);
									}
									continue;
								}
								if (list2 != null && list2.Count > 0)
								{
									foreach (ItemData item3 in list2)
									{
										inventory.Items.Remove(item3);
									}
									List<ItemData> items = inventory.Items;
									if (items != null && items.Count == 0)
									{
										(list ?? (list = new List<ServersideQoLZDO>())).Add(item);
									}
								}
								zdo.ReleaseOwnership();
								num2 += (float)num6;
								vars = zdo.Vars;
								((ZDOVars)(ref vars)).SetFuel(num2, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 177);
								inventory.Save();
								num4 += num6;
								if (num3 != 0)
								{
									continue;
								}
								break;
							}
							if (list != null)
							{
								foreach (ServersideQoLZDO item4 in list)
								{
									current.Remove(item4);
								}
							}
							if (num3 == 0)
							{
								break;
							}
						}
					}
					finally
					{
						((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
					if (num4 != 0)
					{
						Processor.ShowMessage((IEnumerable<Peer>)peers, zdo, ConfigBase<Config>.Instance.Localization.Value.FormatFuelAdded(prefabInfo.Smelter?.m_name ?? prefabInfo.ShieldGenerator.m_name, fuelItem.m_shared.m_name, num4), ConfigBase<Config>.Instance.OreOrFuelAddedMessageType.Value, (TextType)0);
					}
					if (num3 == 0)
					{
						break;
					}
				}
			}
			if (prefabInfo.Smelter != null)
			{
				int num10 = zdo.Fields<Smelter>().GetInt((Func<Expression<Func<Smelter, int>>>)(() => (Smelter x) => x.m_maxOre), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 212);
				vars = zdo.Vars;
				int num11 = ((ZDOVars)(ref vars)).GetQueued(0);
				int num12 = num10 - num11;
				if (num12 > num10 / 2)
				{
					foreach (ItemConversion item5 in prefabInfo.Smelter.m_conversion)
					{
						ItemData oreItem = item5.m_from.m_itemData;
						int num13 = 0;
						AdjacentEnumerator<SharedItemDataKey, HashSet<ServersideQoLZDO>> enumerator8 = _containersByItemName.EnumerateAdjacent((zdo.ZDO.GetPosition(), SharedItemDataKey.op_Implicit(oreItem.m_shared))).GetEnumerator();
						try
						{
							while (enumerator8.MoveNext())
							{
								HashSet<ServersideQoLZDO> current7 = enumerator8.Current;
								list?.Clear();
								foreach (ServersideQoLZDO item6 in current7)
								{
									if (ExcludedContainers.Contains(item6.ZDO.GetPrefab()))
									{
										continue;
									}
									ContainerState state2 = Processor.Instance<ContainerRegistryProcessor>().GetState(item6);
									if (state2 == null)
									{
										(list ?? (list = new List<ServersideQoLZDO>())).Add(item6);
										continue;
									}
									vars = item6.Vars;
									if (((ZDOVars)(ref vars)).GetInUse(false))
									{
										continue;
									}
									float num14 = state2.AutoProcessFeedRange ?? ConfigBase<Config>.Instance.FeedFromContainersRange.Value;
									num14 *= num14;
									if (num14 == 0f || Utils.DistanceSqr(zdo.ZDO.GetPosition(), item6.ZDO.GetPosition()) > num14)
									{
										continue;
									}
									IInventory inventory2 = state2.GetInventory();
									list2?.Clear();
									int num15 = 0;
									int num16 = ConfigBase<Config>.Instance.FeedFromContainersLeaveAtLeastOre.Value;
									bool flag3 = false;
									bool flag4 = false;
									foreach (ItemData item7 in from x in inventory2.Items
										where new ItemDataKey(x) == ItemDataKey.op_Implicit(oreItem)
										orderby x.m_stack
										select x)
									{
										flag3 = flag3 || (item7 != null && item7.m_stack > 0);
										int num17 = Math.Min(item7.m_stack, num16);
										int num18 = Math.Min(num12, item7.m_stack - num17);
										num16 -= num17;
										if (num18 != 0)
										{
											if (!item6.IsOwnerOrUnassigned())
											{
												flag4 = true;
												break;
											}
											num15 += num18;
											item7.m_stack -= num18;
											if (item7.m_stack == 0)
											{
												(list2 ?? (list2 = new List<ItemData>())).Add(item7);
											}
											num12 -= num18;
											if (num12 == 0)
											{
												break;
											}
										}
									}
									if (flag4)
									{
										val |= ((Processor)this).ScheduleReprocessing(Processor.Instance<ContainerRegistryProcessor>().RequestOwnership(item6, default(PlayerID)));
										continue;
									}
									if (num15 == 0)
									{
										if (!flag3)
										{
											(list ?? (list = new List<ServersideQoLZDO>())).Add(item6);
										}
										continue;
									}
									if (list2 != null && list2.Count > 0)
									{
										foreach (ItemData item8 in list2)
										{
											inventory2.Items.Remove(item8);
										}
										List<ItemData> items = inventory2.Items;
										if (items != null && items.Count == 0)
										{
											(list ?? (list = new List<ServersideQoLZDO>())).Add(item6);
										}
									}
									zdo.ReleaseOwnership();
									for (int num19 = 0; num19 < num15; num19++)
									{
										vars = zdo.Vars;
										((ZDOVars)(ref vars)).SetItem(num11 + num19, ((Object)((Component)item5.m_from).gameObject).name, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 297);
									}
									num11 += num15;
									vars = zdo.Vars;
									((ZDOVars)(ref vars)).SetQueued(num11, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.AutoProcess\\SmelterProcessor.cs", 299);
									inventory2.Save();
									num13 += num15;
									if (num12 != 0)
									{
										continue;
									}
									break;
								}
								if (list != null)
								{
									foreach (ServersideQoLZDO item9 in list)
									{
										current7.Remove(item9);
									}
								}
								if (num12 == 0)
								{
									break;
								}
							}
						}
						finally
						{
							((IDisposable)enumerator8/*cast due to .constrained prefix*/).Dispose();
						}
						if (num13 != 0)
						{
							Processor.ShowMessage((IEnumerable<Peer>)peers, zdo, ConfigBase<Config>.Instance.Localization.Value.FormatOreAdded(prefabInfo.Smelter.m_name, oreItem.m_shared.m_name, num13), ConfigBase<Config>.Instance.OreOrFuelAddedMessageType.Value, (TextType)0);
						}
						if (num12 == 0)
						{
							break;
						}
					}
				}
			}
			SectorDictionary.TryAdd(_smelters, zdo, true);
			return val;
		}

		private void OnContainerChanged(ServersideQoLZDO containerZdo, ContainerState state)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (_smelters == null)
			{
				Processor.Instance<ContainerRegistryProcessor>().ContainerChanged -= OnContainerChanged;
			}
			else
			{
				if (ExcludedContainers.Contains(containerZdo.ZDO.GetPrefab()))
				{
					return;
				}
				float num = state.AutoProcessFeedRange ?? ConfigBase<Config>.Instance.FeedFromContainersRange.Value;
				num *= num;
				if (num == 0f)
				{
					return;
				}
				IInventory inventory = state.GetInventory();
				if (inventory == null)
				{
					return;
				}
				List<ItemData> items = inventory.Items;
				if (items == null || items.Count <= 0)
				{
					return;
				}
				AdjacentEnumerator<HashSet<ServersideQoLZDO>> enumerator = _smelters.EnumerateAdjacent(containerZdo.ZDO.GetPosition()).GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						HashSet<ServersideQoLZDO> current = enumerator.Current;
						foreach (ServersideQoLZDO item in current)
						{
							if (Utils.DistanceSqr(item.ZDO.GetPosition(), containerZdo.ZDO.GetPosition()) <= num)
							{
								((Processor)this).ScheduleReprocessing(item, 0f);
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}
	}
}