using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Digitalroot.Valheim.Common;
using Digitalroot.Valheim.Common.Json;
using Digitalroot.Valheim.Common.Names.Vanilla;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn.Managers;
using Jotunn.Utils;
using SimpleJson;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Digitalroot.ValheimBetterWisps")]
[assembly: AssemblyDescription("Better Wisps")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Digitalroot Technologies")]
[assembly: AssemblyProduct("Digitalroot Valheim Mods")]
[assembly: AssemblyCopyright("Copyright © Digitalroot Technologies 2021 - 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3ccc4dc1-5b17-47c1-b996-ca03b8639a61")]
[assembly: AssemblyFileVersion("1.0.27")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.27.0")]
[module: UnverifiableCode]
namespace Digitalroot.Valheim.BetterWisps
{
	[BepInPlugin("digitalroot.mods.betterWisps", "Better Wisps", "1.0.27")]
	[BepInDependency("com.jotunn.jotunn", "2.10.0")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Main : BaseUnityPlugin, ITraceableLogging
	{
		private Harmony _harmony;

		[UsedImplicitly]
		public static ConfigEntry<int> NexusId;

		public static ConfigEntry<float> BaseRange;

		public static ConfigEntry<float> IncreasedRangePerLevel;

		public static ConfigEntry<int> MaxLevel;

		public static ConfigEntry<int> WispsPerLevel;

		public static ConfigEntry<int> SilverPerLevel;

		public static Main Instance;

		public const string Version = "1.0.27";

		public const string Name = "Better Wisps";

		public const string Guid = "digitalroot.mods.betterWisps";

		public const string Namespace = "Digitalroot.ValheimBetterWisps";

		public string Source => "Digitalroot.ValheimBetterWisps";

		public bool EnableTrace { get; }

		public Main()
		{
			try
			{
				Instance = this;
				EnableTrace = false;
				Log.Trace(Instance, "Digitalroot.ValheimBetterWisps." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
			}
			catch (Exception ex)
			{
				ZLog.LogError((object)ex);
			}
		}

		[UsedImplicitly]
		private void Awake()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBetterWisps." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				NexusId = ((BaseUnityPlugin)this).Config.Bind<int>("General", "NexusID", 2150, new ConfigDescription("Nexus mod ID for updates", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Browsable = false,
					ReadOnly = true
				} }));
				BaseRange = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Base Range", 15f, new ConfigDescription("Base clear range of the Wisp Light.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), new object[1] { (object)new ConfigurationManagerAttributes
				{
					IsAdminOnly = true,
					Order = 11
				} }));
				IncreasedRangePerLevel = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Increased Range Per Level", 5f, new ConfigDescription("How much the clear range is Increased per level of the Wisp Light.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), new object[1] { (object)new ConfigurationManagerAttributes
				{
					IsAdminOnly = true,
					Order = 10
				} }));
				MaxLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Advanced", "Max Level", 5, new ConfigDescription("Max level of the Wisp Light.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 25), new object[1] { (object)new ConfigurationManagerAttributes
				{
					IsAdminOnly = true,
					IsAdvanced = true,
					Order = 4
				} }));
				WispsPerLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Advanced", "Wisps Per Level", 5, new ConfigDescription("Amount of Wisps needed per level.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), new object[1] { (object)new ConfigurationManagerAttributes
				{
					IsAdminOnly = true,
					IsAdvanced = true,
					Order = 3
				} }));
				SilverPerLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Advanced", "Silver Per Level", 10, new ConfigDescription("Amount of Silver needed per level.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), new object[1] { (object)new ConfigurationManagerAttributes
				{
					IsAdminOnly = true,
					IsAdvanced = true,
					Order = 2
				} }));
				_harmony = Harmony.CreateAndPatchAll(typeof(Main).Assembly, "digitalroot.mods.betterWisps");
				ItemManager.OnItemsRegisteredFejd += OnItemsRegisteredFejd;
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		private void OnItemsRegisteredFejd()
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBetterWisps." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				UpdateWisp();
				MaxLevel.SettingChanged += UpdateSettings;
				WispsPerLevel.SettingChanged += UpdateSettings;
				SilverPerLevel.SettingChanged += UpdateSettings;
				ItemManager.OnItemsRegisteredFejd -= OnItemsRegisteredFejd;
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		private static void UpdateSettings(object sender, EventArgs e)
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBetterWisps." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				UpdateWisp();
			}
			catch (Exception e2)
			{
				Log.Error(Instance, e2);
			}
		}

		[UsedImplicitly]
		private void OnDestroy()
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBetterWisps." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		private static void UpdateWisp()
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBetterWisps." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				foreach (Recipe item2 in ObjectDB.instance.m_recipes.Where(delegate(Recipe r)
				{
					ItemDrop item = r.m_item;
					return ((item != null) ? ((Object)item).name : null) == ItemDropNames.Demister;
				}))
				{
					Requirement val = ((IEnumerable<Requirement>)item2.m_resources).FirstOrDefault((Func<Requirement, bool>)((Requirement r) => ((Object)r.m_resItem).name == ItemDropNames.Wisp));
					if (val != null)
					{
						val.m_amountPerLevel = WispsPerLevel.Value;
					}
					Log.Trace(Instance, $"Updated {((Object)item2.m_item).name} of {((Object)item2).name}, set {((val != null) ? ((Object)val.m_resItem).name : null)} m_amountPerLevel to {val?.m_amountPerLevel}");
					Requirement val2 = ((IEnumerable<Requirement>)item2.m_resources).FirstOrDefault((Func<Requirement, bool>)((Requirement r) => Object.op_Implicit((Object)(object)(r.m_resItem = Cache.GetPrefab<ItemDrop>(ItemDropNames.Silver)))));
					if (val2 != null)
					{
						val2.m_amountPerLevel = SilverPerLevel.Value;
					}
					Log.Trace(Instance, $"Updated {((Object)item2.m_item).name} of {((Object)item2).name}, set {((val2 != null) ? ((Object)val2.m_resItem).name : null)} m_amountPerLevel to {val2?.m_amountPerLevel}");
				}
				GameObject val3 = ((IEnumerable<GameObject>)ObjectDB.instance.m_items).FirstOrDefault((Func<GameObject, bool>)((GameObject i) => ((Object)i).name == ItemDropNames.Demister));
				ItemDrop val4 = ((val3 != null) ? val3.GetComponent<ItemDrop>() : null);
				if (!((Object)(object)val4 == (Object)null))
				{
					val4.m_itemData.m_shared.m_maxQuality = MaxLevel.Value;
					Log.Trace(Instance, $"Updated {((Object)val3).name} set m_maxQuality to {val4.m_itemData.m_shared.m_maxQuality}");
				}
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}
	}
	[UsedImplicitly]
	public class Patch
	{
		[UsedImplicitly]
		[HarmonyPatch(typeof(Demister))]
		public static class PatchDemisterOnEnable
		{
			[HarmonyPostfix]
			[HarmonyPriority(400)]
			[HarmonyPatch(typeof(Demister), "OnEnable")]
			public static void Postfix([NotNull] ref Demister __instance)
			{
				try
				{
					Log.Trace(Main.Instance, "Digitalroot.ValheimBetterWisps." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
					if (!Utils.IsHeadless() && Utils.IsZNetSceneReady() && Utils.IsPlayerReady())
					{
						ItemData val = ((IEnumerable<ItemData>)((Humanoid)Utils.GetLocalPlayer()).GetInventory().GetEquippedItems()).FirstOrDefault((Func<ItemData, bool>)((ItemData i) => ((Object)i.m_dropPrefab).name == ItemDropNames.Demister));
						if (((Behaviour)__instance).isActiveAndEnabled && val != null)
						{
							__instance.m_forceField.endRange = Main.BaseRange.Value + Main.IncreasedRangePerLevel.Value * (float)(val.m_quality - 1);
							Log.Trace(Main.Instance, $"[{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}.{MethodBase.GetCurrentMethod()?.Name}] Updated {((Object)val.m_dropPrefab).name} range to {__instance.m_forceField.endRange}.");
						}
					}
				}
				catch (Exception e)
				{
					Log.Error(Main.Instance, e);
				}
			}
		}
	}
}
namespace Digitalroot.Valheim.Common
{
	internal interface ITraceableLogging
	{
		string Source { get; }

		bool EnableTrace { get; }
	}
	internal sealed class Log
	{
		private static readonly Dictionary<string, TraceLogger> TraceLoggers;

		[UsedImplicitly]
		private static Log Instance { get; }

		static Log()
		{
			TraceLoggers = new Dictionary<string, TraceLogger>();
			Instance = new Log();
		}

		private Log()
		{
			TraceLoggers.Add("Digitalroot", new TraceLogger("Digitalroot", enableTrace: false));
		}

		public static void RegisterSource(ITraceableLogging sender)
		{
			if ((!TraceLoggers.ContainsKey(sender.Source) || TraceLoggers[sender.Source].IsTraceEnabled != sender.EnableTrace) && (!TraceLoggers.ContainsKey(sender.Source) || sender.EnableTrace))
			{
				if (TraceLoggers.ContainsKey(sender.Source) && sender.EnableTrace)
				{
					TraceLoggers[sender.Source].EnableTrace();
				}
				else
				{
					TraceLoggers.Add(sender.Source, new TraceLogger(sender.Source, sender.EnableTrace));
				}
			}
		}

		private static TraceLogger GetTraceLogger(ITraceableLogging sender)
		{
			if (!TraceLoggers.ContainsKey(sender.Source))
			{
				return TraceLoggers["Digitalroot"];
			}
			return TraceLoggers[sender.Source];
		}

		[UsedImplicitly]
		public static void SetEnableTrace(ITraceableLogging sender, bool value)
		{
			if (value)
			{
				GetTraceLogger(sender).EnableTrace();
			}
			else
			{
				GetTraceLogger(sender).DisableTrace();
			}
		}

		[UsedImplicitly]
		public static void SetEnableTraceForAllLoggers(bool value)
		{
			foreach (TraceLogger value2 in TraceLoggers.Values)
			{
				if (value)
				{
					value2.EnableTrace();
				}
				else
				{
					value2.DisableTrace();
				}
			}
		}

		[UsedImplicitly]
		public static void Debug(ITraceableLogging sender, object value)
		{
			GetTraceLogger(sender).LoggerRef.LogDebug(value);
		}

		[UsedImplicitly]
		public static void Error(ITraceableLogging sender, Exception e, int i = 1)
		{
			Error(sender, "Message: " + e.Message);
			Error(sender, $"TargetSite: {e.TargetSite}");
			Error(sender, "StackTrace: " + e.StackTrace);
			Error(sender, "Source: " + e.Source);
			if (e.Data.Count > 0)
			{
				foreach (object key in e.Data.Keys)
				{
					Error(sender, $"key: {key}, value: {e.Data[key]}");
				}
			}
			if (e.InnerException != null)
			{
				Error(sender, $"--- InnerException [{i}][Start] ---");
				Error(sender, e.InnerException, ++i);
			}
		}

		[UsedImplicitly]
		public static void Error(ITraceableLogging sender, object value)
		{
			GetTraceLogger(sender).LoggerRef.LogError(value);
		}

		[UsedImplicitly]
		public static void Info(ITraceableLogging sender, object value)
		{
			GetTraceLogger(sender).LoggerRef.LogInfo(value);
		}

		[UsedImplicitly]
		public static void Fatal(ITraceableLogging sender, Exception e, int i = 1)
		{
			Fatal(sender, "Message: " + e.Message);
			Fatal(sender, $"TargetSite: {e.TargetSite}");
			Fatal(sender, "StackTrace: " + e.StackTrace);
			Fatal(sender, "Source: " + e.Source);
			if (e.Data.Count > 0)
			{
				foreach (object key in e.Data.Keys)
				{
					Fatal(sender, $"key: {key}, value: {e.Data[key]}");
				}
			}
			if (e.InnerException != null)
			{
				Fatal(sender, $"--- InnerException [{i}][Start] ---");
				Fatal(sender, e.InnerException, ++i);
			}
		}

		[UsedImplicitly]
		public static void Fatal(ITraceableLogging sender, object value)
		{
			GetTraceLogger(sender).LoggerRef.LogFatal(value);
		}

		[UsedImplicitly]
		public static void Message(ITraceableLogging sender, object value)
		{
			GetTraceLogger(sender).LoggerRef.LogMessage(value);
		}

		[UsedImplicitly]
		public static void Trace(ITraceableLogging sender, object value)
		{
			if (GetTraceLogger(sender).IsTraceEnabled || sender.EnableTrace)
			{
				GetTraceLogger(sender).LoggerRef.Log((LogLevel)63, value);
			}
		}

		[UsedImplicitly]
		public static void Warning(ITraceableLogging sender, object value)
		{
			GetTraceLogger(sender).LoggerRef.LogWarning(value);
		}
	}
	internal class TraceLogger
	{
		internal readonly ManualLogSource LoggerRef;

		private readonly string _source;

		private readonly FileInfo _traceFileInfo;

		public bool IsTraceEnabled { get; private set; }

		private DirectoryInfo AssemblyDirectory => new FileInfo(Uri.UnescapeDataString(new UriBuilder(Assembly.GetExecutingAssembly().CodeBase).Path)).Directory;

		public TraceLogger(string source, bool enableTrace)
		{
			_source = source;
			IsTraceEnabled = enableTrace;
			LoggerRef = Logger.CreateLogSource(_source);
			_traceFileInfo = new FileInfo(Path.Combine(Paths.BepInExRootPath ?? AssemblyDirectory.FullName, "logs", _source + ".Trace.log"));
			if (_traceFileInfo.DirectoryName != null)
			{
				Directory.CreateDirectory(_traceFileInfo.DirectoryName);
			}
			if (_traceFileInfo.Exists)
			{
				_traceFileInfo.Delete();
				_traceFileInfo.Refresh();
			}
			LoggerRef.LogEvent += OnLogEvent;
		}

		public void EnableTrace()
		{
			IsTraceEnabled = true;
		}

		public void DisableTrace()
		{
			IsTraceEnabled = false;
		}

		[UsedImplicitly]
		public void StopTrace()
		{
			LoggerRef.LogEvent -= OnLogEvent;
		}

		private void OnLogEvent(object sender, LogEventArgs e)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (e.Source.SourceName != _source || !IsTraceEnabled)
			{
				return;
			}
			using Mutex mutex = new Mutex(initiallyOwned: false, "Digitalroot.Valheim.Common.TraceLogger." + _source);
			mutex.WaitOne();
			try
			{
				if (e.Data is string)
				{
					string contents = $"[{e.Level,-7}:{e.Source.SourceName,10}] {e.Data}{Environment.NewLine}";
					File.AppendAllText(_traceFileInfo.FullName, contents, Encoding.UTF8);
				}
				else
				{
					string contents2 = $"[{e.Level,-7}:{e.Source.SourceName,10}] {JsonSerializationProvider.Serialize(e.Data)}{Environment.NewLine}";
					File.AppendAllText(_traceFileInfo.FullName, contents2, Encoding.UTF8);
				}
			}
			finally
			{
				mutex.ReleaseMutex();
			}
		}
	}
}
namespace Digitalroot.Valheim.Common.Json
{
	[UsedImplicitly]
	internal static class JsonSerializationProvider
	{
		[Obsolete("Use Deserialize<T>()")]
		public static T FromJson<T>(string json)
		{
			return Deserialize<T>(json);
		}

		public static T Deserialize<T>(string json)
		{
			return SimpleJson.DeserializeObject<T>(json, (IJsonSerializerStrategy)(object)new DigitalrootJsonSerializerStrategy());
		}

		[Obsolete("Use Serialize()")]
		public static string ToJson(object obj, bool pretty = false)
		{
			return Serialize(obj);
		}

		public static string Serialize(object obj)
		{
			return SimpleJson.SerializeObject(obj, (IJsonSerializerStrategy)(object)new DigitalrootJsonSerializerStrategy());
		}
	}
	internal class DigitalrootJsonSerializerStrategy : PocoJsonSerializerStrategy
	{
		public override bool TrySerializeNonPrimitiveObject(object input, out object output)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!(input is Vector3 val))
			{
				if (input is Quaternion val2)
				{
					output = new float[4] { val2.x, val2.y, val2.z, val2.w };
					return true;
				}
				return ((PocoJsonSerializerStrategy)this).TrySerializeNonPrimitiveObject(input, ref output);
			}
			output = new float[3] { val.x, val.y, val.z };
			return true;
		}

		public override object DeserializeObject(object value, Type type)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (value is string value2)
			{
				if (string.IsNullOrWhiteSpace(value2))
				{
					throw new ArgumentNullException("value");
				}
				if (type == typeof(Vector3))
				{
					if (!(((PocoJsonSerializerStrategy)this).DeserializeObject(value, typeof(float[])) is float[] array) || (array != null && array.Length != 3))
					{
						throw new ArgumentException(string.Format("The value '{0}' can be converted to a {1}.", value, "Vector3"), "value");
					}
					return (object)new Vector3(array[0], array[1], array[2]);
				}
				if (type == typeof(Quaternion))
				{
					if (!(((PocoJsonSerializerStrategy)this).DeserializeObject(value, typeof(float[])) is float[] array2) || (array2 != null && array2.Length != 4))
					{
						throw new ArgumentException(string.Format("The value '{0}' can be converted to a {1}.", value, "Quaternion"), "value");
					}
					return (object)new Quaternion(array2[0], array2[1], array2[2], array2[3]);
				}
				return ((PocoJsonSerializerStrategy)this).DeserializeObject(value, type);
			}
			throw new ArgumentException($"The value '{value}' can be converted to a {type.Name}.", "value");
		}
	}
}
namespace Digitalroot.Valheim.Common.Names.Vanilla
{
	internal static class ItemDropNames
	{
		public static readonly IEnumerable<string> AllNames = Utils.AllNames(typeof(ItemDropNames));

		public static string Acorn = PrefabNames.Acorn;

		public static string Amber = PrefabNames.Amber;

		public static string AmberPearl = PrefabNames.AmberPearl;

		public static string AncientSkull = PrefabNames.AncientSkull;

		public static string AncientSeed = PrefabNames.AncientSeed;

		public static string ArmorCarapaceChest = PrefabNames.ArmorCarapaceChest;

		public static string ArmorCarapaceLegs = PrefabNames.ArmorCarapaceLegs;

		public static string ArmorBronzeChest = PrefabNames.ArmorBronzeChest;

		public static string ArmorBronzeLegs = PrefabNames.ArmorBronzeLegs;

		public static string ArmorIronChest = PrefabNames.ArmorIronChest;

		public static string ArmorIronLegs = PrefabNames.ArmorIronLegs;

		public static string ArmorMageChest = PrefabNames.ArmorMageChest;

		public static string ArmorMageLegs = PrefabNames.ArmorMageLegs;

		public static string ArmorLeatherChest = PrefabNames.ArmorLeatherChest;

		public static string ArmorLeatherLegs = PrefabNames.ArmorLeatherLegs;

		public static string ArmorPaddedCuirass = PrefabNames.ArmorPaddedCuirass;

		public static string ArmorPaddedGreaves = PrefabNames.ArmorPaddedGreaves;

		public static string ArmorRagsChest = PrefabNames.ArmorRagsChest;

		public static string ArmorRagsLegs = PrefabNames.ArmorRagsLegs;

		public static string ArmorRootChest = PrefabNames.ArmorRootChest;

		public static string ArmorRootLegs = PrefabNames.ArmorRootLegs;

		public static string ArmorTrollLeatherChest = PrefabNames.ArmorTrollLeatherChest;

		public static string ArmorTrollLeatherLegs = PrefabNames.ArmorTrollLeatherLegs;

		public static string ArmorWolfChest = PrefabNames.ArmorWolfChest;

		public static string ArmorWolfLegs = PrefabNames.ArmorWolfLegs;

		public static string ArrowBronze = PrefabNames.ArrowBronze;

		public static string ArrowCarapace = PrefabNames.ArrowCarapace;

		public static string ArrowFire = PrefabNames.ArrowFire;

		public static string ArrowFlint = PrefabNames.ArrowFlint;

		public static string ArrowFrost = PrefabNames.ArrowFrost;

		public static string ArrowIron = PrefabNames.ArrowIron;

		public static string ArrowNeedle = PrefabNames.ArrowNeedle;

		public static string ArrowObsidian = PrefabNames.ArrowObsidian;

		public static string ArrowPoison = PrefabNames.ArrowPoison;

		public static string ArrowSilver = PrefabNames.ArrowSilver;

		public static string ArrowWood = PrefabNames.ArrowWood;

		public static string AtgeirBlackmetal = PrefabNames.AtgeirBlackmetal;

		public static string AtgeirBronze = PrefabNames.AtgeirBronze;

		public static string AtgeirHimminAfl = PrefabNames.AtgeirHimminAfl;

		public static string AtgeirIron = PrefabNames.AtgeirIron;

		public static string AxeBlackMetal = PrefabNames.AxeBlackMetal;

		public static string AxeBronze = PrefabNames.AxeBronze;

		public static string AxeFlint = PrefabNames.AxeFlint;

		public static string AxeIron = PrefabNames.AxeIron;

		public static string AxeJotunBane = PrefabNames.AxeJotunBane;

		public static string AxeStone = PrefabNames.AxeStone;

		public static string Barley = PrefabNames.Barley;

		public static string BarleyFlour = PrefabNames.BarleyFlour;

		public static string BarleyWine = PrefabNames.BarleyWine;

		public static string BarleyWineBase = PrefabNames.BarleyWineBase;

		public static string Battleaxe = PrefabNames.Battleaxe;

		public static string BattleaxeCrystal = PrefabNames.BattleaxeCrystal;

		public static string BeechSeeds = PrefabNames.BeechSeeds;

		public static string BeltStrength = PrefabNames.BeltStrength;

		public static string Bilebag = PrefabNames.Bilebag;

		public static string BirchSeeds = PrefabNames.BirchSeeds;

		public static string BlackCore = PrefabNames.BlackCore;

		public static string BlackMarble = PrefabNames.BlackMarble;

		public static string BlackMetal = PrefabNames.BlackMetal;

		public static string BlackMetalScrap = PrefabNames.BlackMetalScrap;

		public static string BlackSoup = PrefabNames.BlackSoup;

		public static string Bloodbag = PrefabNames.Bloodbag;

		public static string BloodPudding = PrefabNames.BloodPudding;

		public static string Blueberries = PrefabNames.Blueberries;

		public static string BoarJerky = PrefabNames.BoarJerky;

		public static string BoltBlackmetal = PrefabNames.BoltBlackmetal;

		public static string BoltBone = PrefabNames.BoltBone;

		public static string BoltCarapace = PrefabNames.BoltCarapace;

		public static string BoltIron = PrefabNames.BoltIron;

		public static string BombBile = PrefabNames.BombBile;

		public static string BombOoze = PrefabNames.BombOoze;

		public static string BoneFragments = PrefabNames.BoneFragments;

		public static string Bow = PrefabNames.Bow;

		public static string BowDraugrFang = PrefabNames.BowDraugrFang;

		public static string BowFineWood = PrefabNames.BowFineWood;

		public static string BowHuntsman = PrefabNames.BowHuntsman;

		public static string BowSpineSnap = PrefabNames.BowSpineSnap;

		public static string Bread = PrefabNames.Bread;

		public static string BreadDough = PrefabNames.BreadDough;

		public static string Bronze = PrefabNames.Bronze;

		public static string BronzeNails = PrefabNames.BronzeNails;

		public static string BronzeScrap = PrefabNames.BronzeScrap;

		public static string BugMeat = PrefabNames.BugMeat;

		public static string CapeDeerHide = PrefabNames.CapeDeerHide;

		public static string CapeFeather = PrefabNames.CapeFeather;

		public static string CapeLinen = PrefabNames.CapeLinen;

		public static string CapeLox = PrefabNames.CapeLox;

		public static string CapeOdin = PrefabNames.CapeOdin;

		public static string CapeTest = PrefabNames.CapeTest;

		public static string CapeTrollHide = PrefabNames.CapeTrollHide;

		public static string CapeWolf = PrefabNames.CapeWolf;

		public static string Carapace = PrefabNames.Carapace;

		public static string Carrot = PrefabNames.Carrot;

		public static string CarrotSeeds = PrefabNames.CarrotSeeds;

		public static string CarrotSoup = PrefabNames.CarrotSoup;

		public static string Chain = PrefabNames.Chain;

		public static string Chicken = PrefabNames.Chicken;

		public static string ChickenEgg = PrefabNames.ChickenEgg;

		public static string ChickenMeat = PrefabNames.ChickenMeat;

		public static string Chitin = PrefabNames.Chitin;

		public static string Cloudberry = PrefabNames.Cloudberry;

		public static string Club = PrefabNames.Club;

		public static string Coal = PrefabNames.Coal;

		public static string Coins = PrefabNames.Coins;

		public static string CookedBugMeat = PrefabNames.CookedBugMeat;

		public static string CookedChickenMeat = PrefabNames.CookedChickenMeat;

		public static string CookedDeerMeat = PrefabNames.CookedDeerMeat;

		public static string CookedEgg = PrefabNames.CookedEgg;

		public static string CookedHareMeat = PrefabNames.CookedHareMeat;

		public static string CookedLoxMeat = PrefabNames.CookedLoxMeat;

		public static string CookedWolfMeat = PrefabNames.CookedWolfMeat;

		public static string CookedMeat = PrefabNames.CookedMeat;

		public static string Copper = PrefabNames.Copper;

		public static string CopperOre = PrefabNames.CopperOre;

		public static string CopperScrap = PrefabNames.CopperScrap;

		public static string CrossbowArbalest = PrefabNames.CrossbowArbalest;

		public static string CryptKey = PrefabNames.CryptKey;

		public static string Crystal = PrefabNames.Crystal;

		public static string Cultivator = PrefabNames.Cultivator;

		public static string Dandelion = PrefabNames.Dandelion;

		public static string DeerHide = PrefabNames.DeerHide;

		public static string DeerMeat = PrefabNames.DeerMeat;

		public static string DeerStew = PrefabNames.DeerStew;

		public static string Demister = PrefabNames.Demister;

		public static string DragonEgg = PrefabNames.DragonEgg;

		public static string DragonTear = PrefabNames.DragonTear;

		public static string DvergrKey = PrefabNames.DvergrKey;

		public static string DvergrKeyFragment = PrefabNames.DvergrKeyFragment;

		public static string DvergrNeedle = PrefabNames.DvergrNeedle;

		public static string Eitr = PrefabNames.Eitr;

		public static string ElderBark = PrefabNames.ElderBark;

		public static string Entrails = PrefabNames.Entrails;

		public static string Eyescream = PrefabNames.Eyescream;

		public static string Feathers = PrefabNames.Feathers;

		public static string FineWood = PrefabNames.FineWood;

		public static string FirCone = PrefabNames.FirCone;

		public static string FishAndBread = PrefabNames.FishAndBread;

		public static string FishAndBreadUncooked = PrefabNames.FishAndBreadUncooked;

		public static string FishAnglerRaw = PrefabNames.FishAnglerRaw;

		public static string FishCooked = PrefabNames.FishCooked;

		public static string FishingBait = PrefabNames.FishingBait;

		public static string FishingBaitAshlands = PrefabNames.FishingBaitAshlands;

		public static string FishingBaitCave = PrefabNames.FishingBaitCave;

		public static string FishingBaitDeepNorth = PrefabNames.FishingBaitDeepNorth;

		public static string FishingBaitForest = PrefabNames.FishingBaitForest;

		public static string FishingBaitMistlands = PrefabNames.FishingBaitMistlands;

		public static string FishingBaitOcean = PrefabNames.FishingBaitOcean;

		public static string FishingBaitPlains = PrefabNames.FishingBaitPlains;

		public static string FishingBaitSwamp = PrefabNames.FishingBaitSwamp;

		public static string FishingRod = PrefabNames.FishingRod;

		public static string FishRaw = PrefabNames.FishRaw;

		public static string FishWraps = PrefabNames.FishWraps;

		public static string Flametal = PrefabNames.Flametal;

		public static string FlametalOre = PrefabNames.FlametalOre;

		public static string Flax = PrefabNames.Flax;

		public static string Flint = PrefabNames.Flint;

		public static string FreezeGland = PrefabNames.FreezeGland;

		public static string GiantBloodSack = PrefabNames.GiantBloodSack;

		public static string GoblinTotem = PrefabNames.GoblinTotem;

		public static string GreydwarfEye = PrefabNames.GreydwarfEye;

		public static string Guck = PrefabNames.Guck;

		public static string Hammer = PrefabNames.Hammer;

		public static string HareMeat = PrefabNames.HareMeat;

		public static string HardAntler = PrefabNames.HardAntler;

		public static string HelmetBronze = PrefabNames.HelmetBronze;

		public static string HelmetCarapace = PrefabNames.HelmetCarapace;

		public static string HelmetDrake = PrefabNames.HelmetDrake;

		public static string HelmetDverger = PrefabNames.HelmetDverger;

		public static string HelmetIron = PrefabNames.HelmetIron;

		public static string HelmetLeather = PrefabNames.HelmetLeather;

		public static string HelmetMage = PrefabNames.HelmetMage;

		public static string HelmetOdin = PrefabNames.HelmetOdin;

		public static string HelmetPadded = PrefabNames.HelmetPadded;

		public static string HelmetRoot = PrefabNames.HelmetRoot;

		public static string HelmetTrollLeather = PrefabNames.HelmetTrollLeather;

		public static string HelmetYule = PrefabNames.HelmetYule;

		public static string Hoe = PrefabNames.Hoe;

		public static string Honey = PrefabNames.Honey;

		public static string HoneyGlazedChicken = PrefabNames.HoneyGlazedChicken;

		public static string HoneyGlazedChickenUncooked = PrefabNames.HoneyGlazedChickenUncooked;

		public static string Iron = PrefabNames.Iron;

		public static string IronNails = PrefabNames.IronNails;

		public static string IronOre = PrefabNames.IronOre;

		public static string IronScrap = PrefabNames.IronScrap;

		public static string JuteBlue = PrefabNames.JuteBlue;

		public static string JuteRed = PrefabNames.JuteRed;

		public static string KnifeBlackMetal = PrefabNames.KnifeBlackMetal;

		public static string KnifeButcher = PrefabNames.KnifeButcher;

		public static string KnifeChitin = PrefabNames.KnifeChitin;

		public static string KnifeCopper = PrefabNames.KnifeCopper;

		public static string KnifeFlint = PrefabNames.KnifeFlint;

		public static string KnifeSilver = PrefabNames.KnifeSilver;

		public static string KnifeSkollAndHati = PrefabNames.KnifeSkollAndHati;

		public static string Lantern = PrefabNames.Lantern;

		public static string Larva = PrefabNames.Larva;

		public static string LeatherScraps = PrefabNames.LeatherScraps;

		public static string LinenThread = PrefabNames.LinenThread;

		public static string LoxMeat = PrefabNames.LoxMeat;

		public static string LoxPelt = PrefabNames.LoxPelt;

		public static string LoxPie = PrefabNames.LoxPie;

		public static string LoxPieUncooked = PrefabNames.LoxPieUncooked;

		public static string MaceBronze = PrefabNames.MaceBronze;

		public static string MaceIron = PrefabNames.MaceIron;

		public static string MaceNeedle = PrefabNames.MaceNeedle;

		public static string MaceSilver = PrefabNames.MaceSilver;

		public static string MagicallyStuffedShroom = PrefabNames.MagicallyStuffedShroom;

		public static string MagicallyStuffedShroomUncooked = PrefabNames.MagicallyStuffedShroomUncooked;

		public static string Mandible = PrefabNames.Mandible;

		public static string MeadBaseEitrMinor = PrefabNames.MeadBaseEitrMinor;

		public static string MeadBaseFrostResist = PrefabNames.MeadBaseFrostResist;

		public static string MeadBaseHealthMajor = PrefabNames.MeadBaseHealthMajor;

		public static string MeadBaseHealthMedium = PrefabNames.MeadBaseHealthMedium;

		public static string MeadBaseHealthMinor = PrefabNames.MeadBaseHealthMinor;

		public static string MeadBasePoisonResist = PrefabNames.MeadBasePoisonResist;

		public static string MeadBaseStaminaLingering = PrefabNames.MeadBaseStaminaLingering;

		public static string MeadBaseStaminaMedium = PrefabNames.MeadBaseStaminaMedium;

		public static string MeadBaseStaminaMinor = PrefabNames.MeadBaseStaminaMinor;

		public static string MeadBaseTasty = PrefabNames.MeadBaseTasty;

		public static string MeadEitrMinor = PrefabNames.MeadEitrMinor;

		public static string MeadFrostResist = PrefabNames.MeadFrostResist;

		public static string MeadHealthMedium = PrefabNames.MeadHealthMedium;

		public static string MeadHealthMinor = PrefabNames.MeadHealthMinor;

		public static string MeadPoisonResist = PrefabNames.MeadPoisonResist;

		public static string MeadStaminaLingering = PrefabNames.MeadStaminaLingering;

		public static string MeadStaminaMedium = PrefabNames.MeadStaminaMedium;

		public static string MeadStaminaMinor = PrefabNames.MeadStaminaMinor;

		public static string MeadTasty = PrefabNames.MeadTasty;

		public static string MeatPlatter = PrefabNames.MeatPlatter;

		public static string MeatPlatterUncooked = PrefabNames.MeatPlatterUncooked;

		public static string MechanicalSpring = PrefabNames.MechanicalSpring;

		public static string MinceMeatSauce = PrefabNames.MinceMeatSauce;

		public static string MisthareSupreme = PrefabNames.MisthareSupreme;

		public static string MisthareSupremeUncooked = PrefabNames.MisthareSupremeUncooked;

		public static string MistileKamikaze = PrefabNames.MistileKamikaze;

		public static string Mushroom = PrefabNames.Mushroom;

		public static string MushroomBlue = PrefabNames.MushroomBlue;

		public static string MushroomJotunPuffs = PrefabNames.MushroomJotunPuffs;

		public static string MushroomMagecap = PrefabNames.MushroomMagecap;

		public static string MushroomOmelette = PrefabNames.MushroomOmelette;

		public static string MushroomYellow = PrefabNames.MushroomYellow;

		public static string NeckTail = PrefabNames.NeckTail;

		public static string NeckTailGrilled = PrefabNames.NeckTailGrilled;

		public static string Needle = PrefabNames.Needle;

		public static string Obsidian = PrefabNames.Obsidian;

		public static string Onion = PrefabNames.Onion;

		public static string OnionSeeds = PrefabNames.OnionSeeds;

		public static string OnionSoup = PrefabNames.OnionSoup;

		public static string Ooze = PrefabNames.Ooze;

		public static string PickaxeAntler = PrefabNames.PickaxeAntler;

		public static string PickaxeBronze = PrefabNames.PickaxeBronze;

		public static string PickaxeIron = PrefabNames.PickaxeIron;

		public static string PickaxeStone = PrefabNames.PickaxeStone;

		public static string PineCone = PrefabNames.PineCone;

		public static string PukeBerries = PrefabNames.Pukeberries;

		public static string QueenBee = PrefabNames.QueenBee;

		public static string QueenDrop = PrefabNames.QueenDrop;

		public static string QueensJam = PrefabNames.QueensJam;

		public static string Raspberry = PrefabNames.Raspberry;

		public static string RawMeat = PrefabNames.RawMeat;

		public static string Resin = PrefabNames.Resin;

		public static string RoundLog = PrefabNames.RoundLog;

		public static string RoyalJelly = PrefabNames.RoyalJelly;

		public static string Ruby = PrefabNames.Ruby;

		public static string SaddleLox = PrefabNames.SaddleLox;

		public static string Salad = PrefabNames.Salad;

		public static string Sap = PrefabNames.Sap;

		public static string Sausages = PrefabNames.Sausages;

		public static string ScaleHide = PrefabNames.ScaleHide;

		public static string SerpentMeat = PrefabNames.SerpentMeat;

		public static string SerpentMeatCooked = PrefabNames.SerpentMeatCooked;

		public static string SerpentScale = PrefabNames.SerpentScale;

		public static string SerpentStew = PrefabNames.SerpentStew;

		public static string SharpeningStone = PrefabNames.SharpeningStone;

		public static string ShieldBanded = PrefabNames.ShieldBanded;

		public static string ShieldBlackmetal = PrefabNames.ShieldBlackmetal;

		public static string ShieldBlackmetalTower = PrefabNames.ShieldBlackmetalTower;

		public static string ShieldBoneTower = PrefabNames.ShieldBoneTower;

		public static string ShieldBronzeBuckler = PrefabNames.ShieldBronzeBuckler;

		public static string ShieldCarapace = PrefabNames.ShieldCarapace;

		public static string ShieldCarapaceBuckler = PrefabNames.ShieldCarapaceBuckler;

		public static string ShieldIronBuckler = PrefabNames.ShieldIronBuckler;

		public static string ShieldIronSquare = PrefabNames.ShieldIronSquare;

		public static string ShieldIronTower = PrefabNames.ShieldIronTower;

		public static string ShieldKnight = PrefabNames.ShieldKnight;

		public static string ShieldSerpentscale = PrefabNames.ShieldSerpentscale;

		public static string ShieldSilver = PrefabNames.ShieldSilver;

		public static string ShieldWood = PrefabNames.ShieldWood;

		public static string ShieldWoodTower = PrefabNames.ShieldWoodTower;

		public static string ShocklateSmoothie = PrefabNames.ShocklateSmoothie;

		public static string Silver = PrefabNames.Silver;

		public static string SilverNecklace = PrefabNames.SilverNecklace;

		public static string SilverOre = PrefabNames.SilverOre;

		public static string SledgeCheat = PrefabNames.SledgeCheat;

		public static string SledgeDemolisher = PrefabNames.SledgeDemolisher;

		public static string SledgeIron = PrefabNames.SledgeIron;

		public static string SledgeStagbreaker = PrefabNames.SledgeStagbreaker;

		public static string Softtissue = PrefabNames.Softtissue;

		public static string SpearBronze = PrefabNames.SpearBronze;

		public static string SpearChitin = PrefabNames.SpearChitin;

		public static string SpearElderbark = PrefabNames.SpearElderbark;

		public static string SpearFlint = PrefabNames.SpearFlint;

		public static string SpearWolfFang = PrefabNames.SpearWolfFang;

		public static string StaffFireball = PrefabNames.StaffFireball;

		public static string StaffIceShards = PrefabNames.StaffIceShards;

		public static string StaffShield = PrefabNames.StaffShield;

		public static string StaffSkeleton = PrefabNames.StaffSkeleton;

		public static string Stone = PrefabNames.Stone;

		public static string SurtlingCore = PrefabNames.SurtlingCore;

		public static string SwordBlackmetal = PrefabNames.SwordBlackmetal;

		public static string SwordBronze = PrefabNames.SwordBronze;

		public static string SwordCheat = PrefabNames.SwordCheat;

		public static string SwordIron = PrefabNames.SwordIron;

		public static string SwordIronFire = PrefabNames.SwordIronFire;

		public static string SwordMistwalker = PrefabNames.SwordMistwalker;

		public static string SwordSilver = PrefabNames.SwordSilver;

		public static string Tankard = PrefabNames.Tankard;

		public static string TankardDvergr = PrefabNames.TankardDvergr;

		public static string TankardAnniversary = PrefabNames.TankardAnniversary;

		public static string TankardOdin = PrefabNames.TankardOdin;

		public static string Tar = PrefabNames.Tar;

		public static string ThSwordKrom = PrefabNames.ThSwordKrom;

		public static string Thistle = PrefabNames.Thistle;

		public static string Thunderstone = PrefabNames.Thunderstone;

		public static string Tin = PrefabNames.Tin;

		public static string TinOre = PrefabNames.TinOre;

		public static string Torch = PrefabNames.Torch;

		public static string TorchMist = PrefabNames.TorchMist;

		public static string TrollHide = PrefabNames.TrollHide;

		public static string TrophyAbomination = PrefabNames.TrophyAbomination;

		public static string TrophyBlob = PrefabNames.TrophyBlob;

		public static string TrophyBoar = PrefabNames.TrophyBoar;

		public static string TrophyBonemass = PrefabNames.TrophyBonemass;

		public static string TrophyDeathsquito = PrefabNames.TrophyDeathsquito;

		public static string TrophyDeer = PrefabNames.TrophyDeer;

		public static string TrophyDragonQueen = PrefabNames.TrophyDragonQueen;

		public static string TrophyDraugr = PrefabNames.TrophyDraugr;

		public static string TrophyDraugrElite = PrefabNames.TrophyDraugrElite;

		public static string TrophyDraugrFem = PrefabNames.TrophyDraugrFem;

		public static string TrophyDvergr = PrefabNames.TrophyDvergr;

		public static string TrophyEikthyr = PrefabNames.TrophyEikthyr;

		public static string TrophyFenring = PrefabNames.TrophyFenring;

		public static string TrophyForestTroll = PrefabNames.TrophyForestTroll;

		public static string TrophyFrostTroll = PrefabNames.TrophyFrostTroll;

		public static string TrophyGjall = PrefabNames.TrophyGjall;

		public static string TrophyGoblin = PrefabNames.TrophyGoblin;

		public static string TrophyGoblinBrute = PrefabNames.TrophyGoblinBrute;

		public static string TrophyGoblinKing = PrefabNames.TrophyGoblinKing;

		public static string TrophyGoblinShaman = PrefabNames.TrophyGoblinShaman;

		public static string TrophyGreydwarf = PrefabNames.TrophyGreydwarf;

		public static string TrophyGreydwarfBrute = PrefabNames.TrophyGreydwarfBrute;

		public static string TrophyGreydwarfShaman = PrefabNames.TrophyGreydwarfShaman;

		public static string TrophyGrowth = PrefabNames.TrophyGrowth;

		public static string TrophyHare = PrefabNames.TrophyHare;

		public static string TrophyHatchling = PrefabNames.TrophyHatchling;

		public static string TrophyLeech = PrefabNames.TrophyLeech;

		public static string TrophyLox = PrefabNames.TrophyLox;

		public static string TrophyNeck = PrefabNames.TrophyNeck;

		public static string TrophySeeker = PrefabNames.TrophySeeker;

		public static string TrophySeekerBrute = PrefabNames.TrophySeekerBrute;

		public static string TrophySeekerQueen = PrefabNames.TrophySeekerQueen;

		public static string TrophySerpent = PrefabNames.TrophySerpent;

		public static string TrophySGolem = PrefabNames.TrophySGolem;

		public static string TrophySkeleton = PrefabNames.TrophySkeleton;

		public static string TrophySkeletonPoison = PrefabNames.TrophySkeletonPoison;

		public static string TrophySurtling = PrefabNames.TrophySurtling;

		public static string TrophyTheElder = PrefabNames.TrophyTheElder;

		public static string TrophyTick = PrefabNames.TrophyTick;

		public static string TrophyWolf = PrefabNames.TrophyWolf;

		public static string TrophyWraith = PrefabNames.TrophyWraith;

		public static string Turnip = PrefabNames.Turnip;

		public static string TurnipSeeds = PrefabNames.TurnipSeeds;

		public static string TurnipStew = PrefabNames.TurnipStew;

		public static string TurretBolt = PrefabNames.TurretBolt;

		public static string TurretBoltWood = PrefabNames.TurretBoltWood;

		public static string VegvisirShardBonemass = PrefabNames.VegvisirShardBonemass;

		public static string Wishbone = PrefabNames.Wishbone;

		public static string Wisp = PrefabNames.Wisp;

		public static string WitheredBone = PrefabNames.WitheredBone;

		public static string WolfFang = PrefabNames.WolfFang;

		public static string WolfJerky = PrefabNames.WolfJerky;

		public static string WolfMeat = PrefabNames.WolfMeat;

		public static string WolfMeatSkewer = PrefabNames.WolfMeatSkewer;

		public static string WolfPelt = PrefabNames.WolfPelt;

		public static string Wood = PrefabNames.Wood;

		public static string YagluthDrop = PrefabNames.YagluthDrop;

		public static string YggdrasilPorridge = PrefabNames.YggdrasilPorridge;

		public static string YggdrasilWood = PrefabNames.YggdrasilWood;

		public static string YmirRemains = PrefabNames.YmirRemains;
	}
}
namespace Digitalroot.Valheim.Common
{
	internal static class Utils
	{
		private static readonly ITraceableLogging Logger = GetLogger();

		[UsedImplicitly]
		public static DirectoryInfo AssemblyDirectory => new FileInfo(Uri.UnescapeDataString(new UriBuilder(Assembly.GetExecutingAssembly().CodeBase).Path)).Directory;

		[UsedImplicitly]
		public static bool IsDedicated => ZNet.instance.IsDedicated();

		[UsedImplicitly]
		public static bool IsServer => ZNet.instance.IsServer();

		public static bool IsRunningFromNUnit => AppDomain.CurrentDomain.GetAssemblies().Any((Assembly a) => a.FullName.ToLowerInvariant().StartsWith("nunit.framework"));

		public static string Namespace => "Digitalroot.Valheim.Common";

		private static ITraceableLogging GetLogger()
		{
			return new StaticSourceLogger();
		}

		[UsedImplicitly]
		public static bool IsHeadless()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			return (int)SystemInfo.graphicsDeviceType == 4;
		}

		[UsedImplicitly]
		public static List<T> AllOf<T>()
		{
			return Enum.GetValues(typeof(T)).OfType<T>().ToList();
		}

		[UsedImplicitly]
		public static IEnumerable<string> AllNames(Type type)
		{
			foreach (FieldInfo item in from f1 in type.GetFields()
				where f1.FieldType == typeof(string)
				select f1)
			{
				yield return item.GetValue(null).ToString();
			}
		}

		[UsedImplicitly]
		public static bool DoesPluginExist(string pluginGuid)
		{
			return Chainloader.PluginInfos.Any((KeyValuePair<string, PluginInfo> keyValuePair) => keyValuePair.Value.Metadata.GUID == pluginGuid);
		}

		[UsedImplicitly]
		public static Vector3 GetGroundHeight(int x, int z)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return Utils.GetGroundHeight(new Vector3Int(x, 500, z));
		}

		[UsedImplicitly]
		public static Vector3 GetGroundHeight(float x, float z)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return Utils.GetGroundHeight(new Vector3(x, 500f, z));
		}

		public static Vector3 GetGroundHeight(Vector3Int vector3)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)((Vector3Int)(ref vector3)).x, ZoneSystem.instance.GetGroundHeight(Vector3Int.op_Implicit(vector3)), (float)((Vector3Int)(ref vector3)).z);
		}

		public static Vector3 GetGroundHeight(Vector3 vector3)
		{
			//IL_0000: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(vector3.x, ZoneSystem.instance.GetGroundHeight(vector3), vector3.z);
		}

		[UsedImplicitly]
		public static GameObject GetItemPrefab(string itemName)
		{
			if (!IsObjectDBReady())
			{
				return null;
			}
			return GetObjectDB().GetItemPrefab(itemName);
		}

		[UsedImplicitly]
		public static GameObject GetItemPrefab(int hash)
		{
			if (!IsObjectDBReady())
			{
				return null;
			}
			return GetObjectDB().GetItemPrefab(hash);
		}

		[UsedImplicitly]
		public static Player GetLocalPlayer()
		{
			return Player.m_localPlayer;
		}

		[UsedImplicitly]
		public static Vector3 GetLocalPlayersPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)Player.m_localPlayer).transform.position;
		}

		[UsedImplicitly]
		public static ObjectDB GetObjectDB()
		{
			return ObjectDB.instance;
		}

		[UsedImplicitly]
		public static string GetPluginPath(Type modPluginType)
		{
			return Path.GetDirectoryName(modPluginType.Assembly.Location);
		}

		[UsedImplicitly]
		public static GameObject GetPrefab(string itemName)
		{
			if (!IsZNetSceneReady())
			{
				return null;
			}
			return ZNetScene.instance.GetPrefab(itemName);
		}

		[UsedImplicitly]
		public static GameObject GetPrefab(int hash)
		{
			if (!IsZNetSceneReady())
			{
				return null;
			}
			return ZNetScene.instance.GetPrefab(hash);
		}

		[UsedImplicitly]
		public static T GetPrivateField<T>(object instance, string name)
		{
			FieldInfo field = instance.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (field != null)
			{
				return (T)field.GetValue(instance);
			}
			Log.Error(Logger, "Variable " + name + " does not exist on type: " + instance.GetType());
			return default(T);
		}

		[UsedImplicitly]
		public static object InvokePrivate(object instance, string name, object[] args = null)
		{
			MethodInfo method = instance.GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (method == null)
			{
				Type[] types = ((args == null) ? Type.EmptyTypes : args.Select((object arg) => arg.GetType()).ToArray());
				method = instance.GetType().GetMethod(name, types);
			}
			if (method == null)
			{
				Log.Error(Logger, "Method " + name + " does not exist on type: " + instance.GetType());
				return null;
			}
			return method.Invoke(instance, args);
		}

		[UsedImplicitly]
		public static bool IsGameInMainScene()
		{
			return (Object)(object)ZNetScene.instance != (Object)null;
		}

		[UsedImplicitly]
		public static bool IsObjectDBReady()
		{
			if (!((Object)(object)GetObjectDB() != (Object)null) || GetObjectDB().m_items.Count == 0 || !((Object)(object)GetItemPrefab("Amber") != (Object)null))
			{
				return IsRunningFromNUnit;
			}
			return true;
		}

		[UsedImplicitly]
		public static bool IsPlayerReady()
		{
			return (Object)(object)GetLocalPlayer() != (Object)null;
		}

		[UsedImplicitly]
		public static bool IsZNetSceneReady()
		{
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				List<GameObject> list = ZNetScene.instance?.m_prefabs;
				if (list != null)
				{
					return list.Count > 0;
				}
				return false;
			}
			return false;
		}

		[UsedImplicitly]
		public static bool IsZNetReady()
		{
			return (Object)(object)ZNet.instance != (Object)null;
		}

		[UsedImplicitly]
		public static string Localize(string value)
		{
			return Localization.instance.Localize(value);
		}

		[UsedImplicitly]
		public static Vector3 GetStartTemplesPosition()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			LocationInstance val = default(LocationInstance);
			if (ZoneSystem.instance.FindClosestLocation("StartTemple", Vector3.zero, ref val))
			{
				Log.Trace(Logger, $"[GetStartTemplesPosition] StartTemple at {val.m_position}");
				return val.m_position;
			}
			Log.Error(Logger, "[GetStartTemplesPosition] Can't find StartTemple");
			return Vector3.zero;
		}

		[UsedImplicitly]
		public static void SetPrivateField(object instance, string name, object value)
		{
			FieldInfo field = instance.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				Log.Error(Logger, "Variable " + name + " does not exist on type: " + instance.GetType());
			}
			else
			{
				field.SetValue(instance, value);
			}
		}

		[UsedImplicitly]
		public static GameObject Spawn([NotNull] string prefabName, Vector3 location, [CanBeNull] Transform parent = null)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Log.Trace(Logger, $"{Namespace}.{MethodBase.GetCurrentMethod().DeclaringType?.Name}.{MethodBase.GetCurrentMethod().Name}({prefabName}, {location}, {((parent != null) ? ((Object)parent).name : null)})");
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(prefabName));
			if (!((Object)(object)itemPrefab == (Object)null))
			{
				return Spawn(itemPrefab, location, parent);
			}
			return null;
		}

		[UsedImplicitly]
		public static GameObject Spawn([NotNull] GameObject prefab, Vector3 location, [CanBeNull] Transform parent = null)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			Log.Trace(Logger, $"{Namespace}.{MethodBase.GetCurrentMethod().DeclaringType?.Name}.{MethodBase.GetCurrentMethod().Name}({((Object)prefab).name}, {location}, {((parent != null) ? ((Object)parent).name : null)})");
			if ((Object)(object)parent == (Object)null)
			{
				return Object.Instantiate<GameObject>(prefab, location, Quaternion.identity);
			}
			return Object.Instantiate<GameObject>(prefab, location, Quaternion.identity, parent);
		}

		public static AssetBundle LoadAssetBundleFromResources(string bundleName, Assembly resourceAssembly)
		{
			if (resourceAssembly == null)
			{
				throw new ArgumentNullException("resourceAssembly");
			}
			string text = null;
			try
			{
				text = resourceAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(bundleName));
			}
			catch (Exception)
			{
			}
			if (text == null)
			{
				Log.Error(Logger, "AssetBundle " + bundleName + " not found in assembly manifest");
				return null;
			}
			using Stream stream = resourceAssembly.GetManifestResourceStream(text);
			return AssetBundle.LoadFromStream(stream);
		}
	}
}
namespace Digitalroot.Valheim.Common.Names.Vanilla
{
	internal static class PrefabNames
	{
		public static readonly IEnumerable<string> AllNames = Utils.AllNames(typeof(PrefabNames));

		public static readonly string EventzoneBossBase = "_eventzone_boss_base";

		public static readonly string TerrainCompiler = "_TerrainCompiler";

		public static readonly string ZoneCtrl = "_ZoneCtrl";

		public static readonly string AbandonedLogCabin02 = "AbandonedLogCabin02";

		public static readonly string AbandonedLogCabin03 = "AbandonedLogCabin03";

		public static readonly string AbandonedLogCabin04 = "AbandonedLogCabin04";

		public static readonly string Abomination = "Abomination";

		public static readonly string AbominationAttack1 = "Abomination_attack1";

		public static readonly string AbominationAttack2 = "Abomination_attack2";

		public static readonly string AbominationAttack3 = "Abomination_attack3";

		public static readonly string AbominationRagdoll = "Abomination_ragdoll";

		public static readonly string Acorn = "Acorn";

		public static readonly string Amber = "Amber";

		public static readonly string AmberPearl = "AmberPearl";

		public static readonly string AncientSkull = "ancient_skull";

		public static readonly string AncientbarkspearProjectile = "ancientbarkspear_projectile";

		public static readonly string AncientSeed = "AncientSeed";

		public static readonly string AoeNova = "aoe_nova";

		public static readonly string ArbalestProjectileBlackmetal = "arbalest_projectile_blackmetal";

		public static readonly string ArbalestProjectileBone = "arbalest_projectile_bone";

		public static readonly string ArbalestProjectileCarapace = "arbalest_projectile_carapace";

		public static readonly string ArmorBronzeChest = "ArmorBronzeChest";

		public static readonly string ArmorBronzeLegs = "ArmorBronzeLegs";

		public static readonly string ArmorCarapaceChest = "ArmorCarapaceChest";

		public static readonly string ArmorCarapaceLegs = "ArmorCarapaceLegs";

		public static readonly string ArmorDress1 = "ArmorDress1";

		public static readonly string ArmorDress10 = "ArmorDress10";

		public static readonly string ArmorDress2 = "ArmorDress2";

		public static readonly string ArmorDress3 = "ArmorDress3";

		public static readonly string ArmorDress4 = "ArmorDress4";

		public static readonly string ArmorDress5 = "ArmorDress5";

		public static readonly string ArmorDress6 = "ArmorDress6";

		public static readonly string ArmorDress7 = "ArmorDress7";

		public static readonly string ArmorDress8 = "ArmorDress8";

		public static readonly string ArmorDress9 = "ArmorDress9";

		public static readonly string ArmorFenringChest = "ArmorFenringChest";

		public static readonly string ArmorFenringLegs = "ArmorFenringLegs";

		public static readonly string ArmorIronChest = "ArmorIronChest";

		public static readonly string ArmorIronLegs = "ArmorIronLegs";

		public static readonly string ArmorLeatherChest = "ArmorLeatherChest";

		public static readonly string ArmorLeatherLegs = "ArmorLeatherLegs";

		public static readonly string ArmorMageChest = "ArmorMageChest";

		public static readonly string ArmorMageLegs = "ArmorMageLegs";

		public static readonly string ArmorPaddedCuirass = "ArmorPaddedCuirass";

		public static readonly string ArmorPaddedGreaves = "ArmorPaddedGreaves";

		public static readonly string ArmorRagsChest = "ArmorRagsChest";

		public static readonly string ArmorRagsLegs = "ArmorRagsLegs";

		public static readonly string ArmorRootChest = "ArmorRootChest";

		public static readonly string ArmorRootLegs = "ArmorRootLegs";

		public static readonly string ArmorStand = "ArmorStand";

		public static readonly string ArmorStandFemale = "ArmorStand_Female";

		public static readonly string ArmorStandMale = "ArmorStand_Male";

		public static readonly string ArmorTrollLeatherChest = "ArmorTrollLeatherChest";

		public static readonly string ArmorTrollLeatherLegs = "ArmorTrollLeatherLegs";

		public static readonly string ArmorTunic1 = "ArmorTunic1";

		public static readonly string ArmorTunic10 = "ArmorTunic10";

		public static readonly string ArmorTunic2 = "ArmorTunic2";

		public static readonly string ArmorTunic3 = "ArmorTunic3";

		public static readonly string ArmorTunic4 = "ArmorTunic4";

		public static readonly string ArmorTunic5 = "ArmorTunic5";

		public static readonly string ArmorTunic6 = "ArmorTunic6";

		public static readonly string ArmorTunic7 = "ArmorTunic7";

		public static readonly string ArmorTunic8 = "ArmorTunic8";

		public static readonly string ArmorTunic9 = "ArmorTunic9";

		public static readonly string ArmorWolfChest = "ArmorWolfChest";

		public static readonly string ArmorWolfLegs = "ArmorWolfLegs";

		public static readonly string ArrowBronze = "ArrowBronze";

		public static readonly string ArrowCarapace = "ArrowCarapace";

		public static readonly string ArrowFire = "ArrowFire";

		public static readonly string ArrowFlint = "ArrowFlint";

		public static readonly string ArrowFrost = "ArrowFrost";

		public static readonly string ArrowIron = "ArrowIron";

		public static readonly string ArrowNeedle = "ArrowNeedle";

		public static readonly string ArrowObsidian = "ArrowObsidian";

		public static readonly string ArrowPoison = "ArrowPoison";

		public static readonly string ArrowSilver = "ArrowSilver";

		public static readonly string ArrowWood = "ArrowWood";

		public static readonly string AtgeirBlackmetal = "AtgeirBlackmetal";

		public static readonly string AtgeirBronze = "AtgeirBronze";

		public static readonly string AtgeirHimminAfl = "AtgeirHimminAfl";

		public static readonly string AtgeirIron = "AtgeirIron";

		public static readonly string AxeBlackMetal = "AxeBlackMetal";

		public static readonly string AxeBronze = "AxeBronze";

		public static readonly string AxeFlint = "AxeFlint";

		public static readonly string AxeIron = "AxeIron";

		public static readonly string AxeJotunBane = "AxeJotunBane";

		public static readonly string AxeStone = "AxeStone";

		public static readonly string BarberKit = "BarberKit";

		public static readonly string Barley = "Barley";

		public static readonly string BarleyFlour = "BarleyFlour";

		public static readonly string BarleyWine = "BarleyWine";

		public static readonly string BarleyWineBase = "BarleyWineBase";

		public static readonly string Barrell = "barrell";

		public static readonly string Bat = "Bat";

		public static readonly string BatMelee = "bat_melee";

		public static readonly string Battleaxe = "Battleaxe";

		public static readonly string BattleaxeCrystal = "BattleaxeCrystal";

		public static readonly string Bed = "bed";

		public static readonly string BeeAoe = "bee_aoe";

		public static readonly string BeechLog = "beech_log";

		public static readonly string BeechLogHalf = "beech_log_half";

		public static readonly string BeechSapling = "Beech_Sapling";

		public static readonly string BeechSmall1 = "Beech_small1";

		public static readonly string BeechSmall2 = "Beech_small2";

		public static readonly string BeechStub = "Beech_Stub";

		public static readonly string Beech1 = "Beech1";

		public static readonly string BeechSeeds = "BeechSeeds";

		public static readonly string Beehive = "Beehive";

		public static readonly string BeltStrength = "BeltStrength";

		public static readonly string Bilebag = "Bilebag";

		public static readonly string BilebombExplosion = "bilebomb_explosion";

		public static readonly string BilebombProjectile = "bilebomb_projectile";

		public static readonly string BirchLog = "Birch_log";

		public static readonly string BirchLogHalf = "Birch_log_half";

		public static readonly string BirchSapling = "Birch_Sapling";

		public static readonly string Birch1 = "Birch1";

		public static readonly string Birch1Aut = "Birch1_aut";

		public static readonly string Birch2 = "Birch2";

		public static readonly string Birch2Aut = "Birch2_aut";

		public static readonly string BirchSeeds = "BirchSeeds";

		public static readonly string BirchStub = "BirchStub";

		public static readonly string BlackCore = "BlackCore";

		public static readonly string BlackForestLocationMusic = "BlackForestLocationMusic";

		public static readonly string Blackforge = "blackforge";

		public static readonly string BlackforgeExt1 = "blackforge_ext1";

		public static readonly string BlackforgeExt2Vise = "blackforge_ext2_vise";

		public static readonly string BlackMarble = "BlackMarble";

		public static readonly string Blackmarble1X1 = "blackmarble_1x1";

		public static readonly string Blackmarble2X1X1 = "blackmarble_2x1x1";

		public static readonly string Blackmarble2X2Enforced = "blackmarble_2x2_enforced";

		public static readonly string Blackmarble2X2X1 = "blackmarble_2x2x1";

		public static readonly string Blackmarble2X2X2 = "blackmarble_2x2x2";

		public static readonly string BlackmarbleAltarCrystal = "blackmarble_altar_crystal";

		public static readonly string BlackmarbleAltarCrystalBroken = "blackmarble_altar_crystal_broken";

		public static readonly string BlackmarbleArch = "blackmarble_arch";

		public static readonly string BlackmarbleBase1 = "blackmarble_base_1";

		public static readonly string BlackmarbleBase2 = "blackmarble_base_2";

		public static readonly string BlackmarbleBasecorner = "blackmarble_basecorner";

		public static readonly string BlackmarbleColumn1 = "blackmarble_column_1";

		public static readonly string BlackmarbleColumn2 = "blackmarble_column_2";

		public static readonly string BlackmarbleColumn3 = "blackmarble_column_3";

		public static readonly string BlackmarbleCreep4X1X1 = "blackmarble_creep_4x1x1";

		public static readonly string BlackmarbleCreep4X2X1 = "blackmarble_creep_4x2x1";

		public static readonly string BlackmarbleCreepSlopeInverted1X1X2 = "blackmarble_creep_slope_inverted_1x1x2";

		public static readonly string BlackmarbleCreepSlopeInverted2X2X1 = "blackmarble_creep_slope_inverted_2x2x1";

		public static readonly string BlackmarbleCreepStair = "blackmarble_creep_stair";

		public static readonly string BlackmarbleFloor = "blackmarble_floor";

		public static readonly string BlackmarbleFloorLarge = "blackmarble_floor_large";

		public static readonly string BlackmarbleFloorTriangle = "blackmarble_floor_triangle";

		public static readonly string BlackmarbleHeadBig01 = "blackmarble_head_big01";

		public static readonly string BlackmarbleHeadBig02 = "blackmarble_head_big02";

		public static readonly string BlackmarbleHead01 = "blackmarble_head01";

		public static readonly string BlackmarbleHead02 = "blackmarble_head02";

		public static readonly string BlackmarbleOut1 = "blackmarble_out_1";

		public static readonly string BlackmarbleOut2 = "blackmarble_out_2";

		public static readonly string BlackmarbleOutcorner = "blackmarble_outcorner";

		public static readonly string BlackmarblePile = "blackmarble_pile";

		public static readonly string BlackmarblePost01 = "blackmarble_post01";

		public static readonly string BlackmarbleSlope1X2 = "blackmarble_slope_1x2";

		public static readonly string BlackmarbleSlopeInverted1X2 = "blackmarble_slope_inverted_1x2";

		public static readonly string BlackmarbleStair = "blackmarble_stair";

		public static readonly string BlackmarbleStairCorner = "blackmarble_stair_corner";

		public static readonly string BlackmarbleStairCornerLeft = "blackmarble_stair_corner_left";

		public static readonly string BlackmarbleTileFloor1X1 = "blackmarble_tile_floor_1x1";

		public static readonly string BlackmarbleTileFloor2X2 = "blackmarble_tile_floor_2x2";

		public static readonly string BlackmarbleTileWall1X1 = "blackmarble_tile_wall_1x1";

		public static readonly string BlackmarbleTileWall2X2 = "blackmarble_tile_wall_2x2";

		public static readonly string BlackmarbleTileWall2X4 = "blackmarble_tile_wall_2x4";

		public static readonly string BlackmarbleTip = "blackmarble_tip";

		public static readonly string BlackMetal = "BlackMetal";

		public static readonly string BlackMetalScrap = "BlackMetalScrap";

		public static readonly string BlackSoup = "BlackSoup";

		public static readonly string Blastfurnace = "blastfurnace";

		public static readonly string Blob = "Blob";

		public static readonly string BlobAoe = "blob_aoe";

		public static readonly string BlobElite = "BlobElite";

		public static readonly string BlobTar = "BlobTar";

		public static readonly string BlobtarProjectileTarball = "blobtar_projectile_tarball";

		public static readonly string Bloodbag = "Bloodbag";

		public static readonly string BloodPudding = "BloodPudding";

		public static readonly string Blueberries = "Blueberries";

		public static readonly string BlueberryBush = "BlueberryBush";

		public static readonly string Boar = "Boar";

		public static readonly string BoarPiggy = "Boar_piggy";

		public static readonly string BoarRagdoll = "boar_ragdoll";

		public static readonly string BoarJerky = "BoarJerky";

		public static readonly string BoltBlackmetal = "BoltBlackmetal";

		public static readonly string BoltBone = "BoltBone";

		public static readonly string BoltCarapace = "BoltCarapace";

		public static readonly string BoltIron = "BoltIron";

		public static readonly string BombBile = "BombBile";

		public static readonly string BombOoze = "BombOoze";

		public static readonly string BoneFragments = "BoneFragments";

		public static readonly string Bonemass = "Bonemass";

		public static readonly string Bonemass2 = "Bonemass";

		public static readonly string BonemassAoe = "bonemass_aoe";

		public static readonly string BonemassThrowProjectile = "bonemass_throw_projectile";

		public static readonly string BonePileSpawner = "BonePileSpawner";

		public static readonly string Bonfire = "bonfire";

		public static readonly string BossStoneBonemass = "BossStone_Bonemass";

		public static readonly string BossStoneDragonQueen = "BossStone_DragonQueen";

		public static readonly string BossStoneEikthyr = "BossStone_Eikthyr";

		public static readonly string BossStoneTheElder = "BossStone_TheElder";

		public static readonly string BossStoneTheQueen = "BossStone_TheQueen";

		public static readonly string BossStoneYagluth = "BossStone_Yagluth";

		public static readonly string Bow = "Bow";

		public static readonly string BowProjectile = "bow_projectile";

		public static readonly string BowProjectileCarapace = "bow_projectile_carapace";

		public static readonly string BowProjectileFire = "bow_projectile_fire";

		public static readonly string BowProjectileFrost = "bow_projectile_frost";

		public static readonly string BowProjectileNeedle = "bow_projectile_needle";

		public static readonly string BowProjectilePoison = "bow_projectile_poison";

		public static readonly string BowDraugrFang = "BowDraugrFang";

		public static readonly string BowFineWood = "BowFineWood";

		public static readonly string BowHuntsman = "BowHuntsman";

		public static readonly string BowSpineSnap = "BowSpineSnap";

		public static readonly string Bread = "Bread";

		public static readonly string BreadDough = "BreadDough";

		public static readonly string Bronze = "Bronze";

		public static readonly string BronzeNails = "BronzeNails";

		public static readonly string BronzeScrap = "BronzeScrap";

		public static readonly string BronzespearProjectile = "bronzespear_projectile";

		public static readonly string Bucket = "bucket";

		public static readonly string BugMeat = "BugMeat";

		public static readonly string Bush01 = "Bush01";

		public static readonly string Bush01Heath = "Bush01_heath";

		public static readonly string Bush02En = "Bush02_en";

		public static readonly string CapeDeerHide = "CapeDeerHide";

		public static readonly string CapeFeather = "CapeFeather";

		public static readonly string CapeLinen = "CapeLinen";

		public static readonly string CapeLox = "CapeLox";

		public static readonly string CapeOdin = "CapeOdin";

		public static readonly string CapeTest = "CapeTest";

		public static readonly string CapeTrollHide = "CapeTrollHide";

		public static readonly string CapeWolf = "CapeWolf";

		public static readonly string Carapace = "Carapace";

		public static readonly string CargoCrate = "CargoCrate";

		public static readonly string Carrot = "Carrot";

		public static readonly string CarrotSeeds = "CarrotSeeds";

		public static readonly string CarrotSoup = "CarrotSoup";

		public static readonly string Cart = "Cart";

		public static readonly string CastleKitBraidedBox01 = "CastleKit_braided_box01";

		public static readonly string CastleKitBrazier = "CastleKit_brazier";

		public static readonly string CastleKitGroundtorch = "CastleKit_groundtorch";

		public static readonly string CastleKitGroundtorchBlue = "CastleKit_groundtorch_blue";

		public static readonly string CastleKitGroundtorchGreen = "CastleKit_groundtorch_green";

		public static readonly string CastleKitGroundtorchUnlit = "CastleKit_groundtorch_unlit";

		public static readonly string CastleKitMetalGroundtorchUnlit = "CastleKit_metal_groundtorch_unlit";

		public static readonly string CastleKitPot03 = "CastleKit_pot03";

		public static readonly string CauldronExt1Spice = "cauldron_ext1_spice";

		public static readonly string CauldronExt3Butchertable = "cauldron_ext3_butchertable";

		public static readonly string CauldronExt4Pots = "cauldron_ext4_pots";

		public static readonly string CauldronExt5Mortarandpestle = "cauldron_ext5_mortarandpestle";

		public static readonly string CaverockIcePillarWall = "caverock_ice_pillar_wall";

		public static readonly string CaverockIceStalagmite = "caverock_ice_stalagmite";

		public static readonly string CaverockIceStalagmiteBroken = "caverock_ice_stalagmite_broken";

		public static readonly string CaverockIceStalagmiteDestruction = "caverock_ice_stalagmite_destruction";

		public static readonly string CaverockIceStalagtite = "caverock_ice_stalagtite";

		public static readonly string CaverockIceStalagtiteDestruction = "caverock_ice_stalagtite_destruction";

		public static readonly string CaverockIceStalagtiteFalling = "caverock_ice_stalagtite_falling";

		public static readonly string CaverockIceWallDestruction = "caverock_ice_wall_destruction";

		public static readonly string Chain = "Chain";

		public static readonly string CharcoalKiln = "charcoal_kiln";

		public static readonly string Chest = "Chest";

		public static readonly string ChestHildir1 = "chest_hildir1";

		public static readonly string ChestHildir2 = "chest_hildir2";

		public static readonly string ChestHildir3 = "chest_hildir3";

		public static readonly string Chicken = "Chicken";

		public static readonly string ChickenEgg = "ChickenEgg";

		public static readonly string ChickenMeat = "ChickenMeat";

		public static readonly string Chitin = "Chitin";

		public static readonly string CliffMistlands1 = "cliff_mistlands1";

		public static readonly string CliffMistlands1Creep = "cliff_mistlands1_creep";

		public static readonly string CliffMistlands1CreepFrac = "cliff_mistlands1_creep_frac";

		public static readonly string CliffMistlands1Frac = "cliff_mistlands1_frac";

		public static readonly string CliffMistlands2 = "cliff_mistlands2";

		public static readonly string CliffMistlands2Frac = "cliff_mistlands2_frac";

		public static readonly string ClothHangingDoor = "cloth_hanging_door";

		public static readonly string ClothHangingDoorDouble = "cloth_hanging_door_double";

		public static readonly string ClothHangingLong = "cloth_hanging_long";

		public static readonly string Cloudberry = "Cloudberry";

		public static readonly string CloudberryBush = "CloudberryBush";

		public static readonly string Club = "Club";

		public static readonly string Coal = "Coal";

		public static readonly string CoalPile = "coal_pile";

		public static readonly string Coins = "Coins";

		public static readonly string CookedBugMeat = "CookedBugMeat";

		public static readonly string CookedChickenMeat = "CookedChickenMeat";

		public static readonly string CookedDeerMeat = "CookedDeerMeat";

		public static readonly string CookedEgg = "CookedEgg";

		public static readonly string CookedHareMeat = "CookedHareMeat";

		public static readonly string CookedLoxMeat = "CookedLoxMeat";

		public static readonly string CookedMeat = "CookedMeat";

		public static readonly string CookedWolfMeat = "CookedWolfMeat";

		public static readonly string Copper = "Copper";

		public static readonly string CopperOre = "CopperOre";

		public static readonly string CopperScrap = "CopperScrap";

		public static readonly string CreepPropEggHanging01 = "CreepProp_egg_hanging01";

		public static readonly string CreepPropEggHanging02 = "CreepProp_egg_hanging02";

		public static readonly string CreepPropEntrance1 = "CreepProp_entrance1";

		public static readonly string CreepPropEntrance2 = "CreepProp_entrance2";

		public static readonly string CreepPropHanging01 = "CreepProp_hanging01";

		public static readonly string CreepPropWall01 = "CreepProp_wall01";

		public static readonly string CrossbowArbalest = "CrossbowArbalest";

		public static readonly string Crow = "Crow";

		public static readonly string CryptSkeletonChest = "crypt_skeleton_chest";

		public static readonly string Crypt2 = "Crypt2";

		public static readonly string Crypt3 = "Crypt3";

		public static readonly string Crypt4 = "Crypt4";

		public static readonly string CryptKey = "CryptKey";

		public static readonly string Crystal = "Crystal";

		public static readonly string CrystalWall1X1 = "crystal_wall_1x1";

		public static readonly string Cultivate = "cultivate";

		public static readonly string Cultivator = "Cultivator";

		public static readonly string Dandelion = "Dandelion";

		public static readonly string DarkwoodArch = "darkwood_arch";

		public static readonly string DarkwoodBeam = "darkwood_beam";

		public static readonly string DarkwoodBeam26 = "darkwood_beam_26";

		public static readonly string DarkwoodBeam45 = "darkwood_beam_45";

		public static readonly string DarkwoodBeam4X4 = "darkwood_beam4x4";

		public static readonly string DarkwoodDecowall = "darkwood_decowall";

		public static readonly string DarkwoodGate = "darkwood_gate";

		public static readonly string DarkwoodPole = "darkwood_pole";

		public static readonly string DarkwoodPole4 = "darkwood_pole4";

		public static readonly string DarkwoodRaven = "darkwood_raven";

		public static readonly string DarkwoodRoof = "darkwood_roof";

		public static readonly string DarkwoodRoof45 = "darkwood_roof_45";

		public static readonly string DarkwoodRoofIcorner = "darkwood_roof_icorner";

		public static readonly string DarkwoodRoofIcorner45 = "darkwood_roof_icorner_45";

		public static readonly string DarkwoodRoofOcorner = "darkwood_roof_ocorner";

		public static readonly string DarkwoodRoofOcorner45 = "darkwood_roof_ocorner_45";

		public static readonly string DarkwoodRoofTop = "darkwood_roof_top";

		public static readonly string DarkwoodRoofTop45 = "darkwood_roof_top_45";

		public static readonly string DarkwoodWolf = "darkwood_wolf";

		public static readonly string DeadDeer = "dead_deer";

		public static readonly string Deathsquito = "Deathsquito";

		public static readonly string DeathsquitoSting = "Deathsquito_sting";

		public static readonly string Deer = "Deer";

		public static readonly string DeerRagdoll = "deer_ragdoll";

		public static readonly string DeerGodExplosion = "DeerGodExplosion";

		public static readonly string DeerHide = "DeerHide";

		public static readonly string DeerMeat = "DeerMeat";

		public static readonly string DeerStew = "DeerStew";

		public static readonly string Demister = "Demister";

		public static readonly string DemisterBall = "demister_ball";

		public static readonly string DevFloor1 = "DevFloor1";

		public static readonly string DevGround1 = "DevGround1";

		public static readonly string DevGround2 = "DevGround2";

		public static readonly string DevHouse1 = "DevHouse1";

		public static readonly string DevHouse2 = "DevHouse2";

		public static readonly string DevHouse3 = "DevHouse3";

		public static readonly string DevSoundTest = "DevSoundTest";

		public static readonly string DevSpawnTest = "DevSpawnTest";

		public static readonly string DevWall1 = "DevWall1";

		public static readonly string DgCave = "DG_Cave";

		public static readonly string DgDvergrBoss = "DG_DvergrBoss";

		public static readonly string DgDvergrTown = "DG_DvergrTown";

		public static readonly string DgForestCrypt = "DG_ForestCrypt";

		public static readonly string DgGoblinCamp = "DG_GoblinCamp";

		public static readonly string DgHildirCave = "DG_Hildir_Cave";

		public static readonly string DgHildirForestCrypt = "DG_Hildir_ForestCrypt";

		public static readonly string DgHildirPlainsFortress = "DG_Hildir_PlainsFortress";

		public static readonly string DgMeadowsFarm = "DG_MeadowsFarm";

		public static readonly string DgMeadowsVillage = "DG_MeadowsVillage";

		public static readonly string DgSunkenCrypt = "DG_SunkenCrypt";

		public static readonly string Digg = "digg";

		public static readonly string DiggV2 = "digg_v2";

		public static readonly string Dolmen01 = "Dolmen01";

		public static readonly string Dolmen02 = "Dolmen02";

		public static readonly string Dolmen03 = "Dolmen03";

		public static readonly string Dragon = "Dragon";

		public static readonly string DragonIceProjectile = "dragon_ice_projectile";

		public static readonly string DragonEgg = "DragonEgg";

		public static readonly string Dragoneggcup = "dragoneggcup";

		public static readonly string Dragonqueen = "Dragonqueen";

		public static readonly string DragonTear = "DragonTear";

		public static readonly string DrakeLorestone = "DrakeLorestone";

		public static readonly string DrakeNest01 = "DrakeNest01";

		public static readonly string Draugr = "Draugr";

		public static readonly string DraugrArrow = "draugr_arrow";

		public static readonly string DraugrAxe = "draugr_axe";

		public static readonly string DraugrBow = "draugr_bow";

		public static readonly string DraugrBowProjectile = "draugr_bow_projectile";

		public static readonly string DraugrElite = "Draugr_Elite";

		public static readonly string DraugrEliteRagdoll = "Draugr_elite_ragdoll";

		public static readonly string DraugrRagdoll = "Draugr_ragdoll";

		public static readonly string DraugrRanged = "Draugr_Ranged";

		public static readonly string DraugrRangedRagdoll = "Draugr_ranged_ragdoll";

		public static readonly string DraugrSword = "draugr_sword";

		public static readonly string DungeonForestcryptDoor = "dungeon_forestcrypt_door";

		public static readonly string DungeonQueenDoor = "dungeon_queen_door";

		public static readonly string DungeonSunkencryptIrongate = "dungeon_sunkencrypt_irongate";

		public static readonly string DungeonSunkencryptIrongateRusty = "dungeon_sunkencrypt_irongate_rusty";

		public static readonly string Dverger = "Dverger";

		public static readonly string DvergerDemister = "dverger_demister";

		public static readonly string DvergerDemisterBroken = "dverger_demister_broken";

		public static readonly string DvergerDemisterLarge = "dverger_demister_large";

		public static readonly string DvergerDemisterRuins = "dverger_demister_ruins";

		public static readonly string DvergerGuardstone = "dverger_guardstone";

		public static readonly string DvergerRagdoll = "Dverger_ragdoll";

		public static readonly string DvergerArbalest = "DvergerArbalest";

		public static readonly string DvergerArbalestProjectile = "DvergerArbalest_projectile";

		public static readonly string DvergerArbalestShoot = "DvergerArbalest_shoot";

		public static readonly string DvergerHairFemale = "DvergerHairFemale";

		public static readonly string DvergerHairMale = "DvergerHairMale";

		public static readonly string DvergerMage = "DvergerMage";

		public static readonly string DvergerMageFire = "DvergerMageFire";

		public static readonly string DvergerMageIce = "DvergerMageIce";

		public static readonly string DvergerMageSupport = "DvergerMageSupport";

		public static readonly string DvergerStaffBlockerBlockCircle = "DvergerStaffBlocker_blockCircle";

		public static readonly string DvergerStaffBlockerBlockCircleBig = "DvergerStaffBlocker_blockCircleBig";

		public static readonly string DvergerStaffBlockerBlockHemisphere = "DvergerStaffBlocker_blockHemisphere";

		public static readonly string DvergerStaffBlockerBlockU = "DvergerStaffBlocker_blockU";

		public static readonly string DvergerStaffBlockerBlockWall = "DvergerStaffBlocker_blockWall";

		public static readonly string DvergerStaffBlockerProjectile = "DvergerStaffBlocker_projectile";

		public static readonly string DvergerStaffFire = "DvergerStaffFire";

		public static readonly string DvergerStaffFireClusterbombAoe = "DvergerStaffFire_clusterbomb_aoe";

		public static readonly string DvergerStaffFireClusterbombProjectile = "DvergerStaffFire_clusterbomb_projectile";

		public static readonly string DvergerStaffFireFireAoe = "DvergerStaffFire_fire_aoe";

		public static readonly string DvergerStaffFireFireballProjectile = "DvergerStaffFire_fireball_projectile";

		public static readonly string DvergerStaffHeal = "DvergerStaffHeal";

		public static readonly string DvergerStaffHealAoe = "DvergerStaffHeal_aoe";

		public static readonly string DvergerStaffIce = "DvergerStaffIce";

		public static readonly string DvergerStaffIceProjectile = "DvergerStaffIce_projectile";

		public static readonly string DvergerStaffNovaAoe = "DvergerStaffNova_aoe";

		public static readonly string DvergerStaffSupport = "DvergerStaffSupport";

		public static readonly string DvergerStaffSupportAoe = "DvergerStaffSupport_aoe";

		public static readonly string DvergerSuitArbalest = "DvergerSuitArbalest";

		public static readonly string DvergerSuitFire = "DvergerSuitFire";

		public static readonly string DvergerSuitIce = "DvergerSuitIce";

		public static readonly string DvergerSuitSupport = "DvergerSuitSupport";

		public static readonly string DvergerTest = "DvergerTest";

		public static readonly string DvergrKey = "DvergrKey";

		public static readonly string DvergrKeyFragment = "DvergrKeyFragment";

		public static readonly string DvergrNeedle = "DvergrNeedle";

		public static readonly string DvergrpropsBanner = "dvergrprops_banner";

		public static readonly string DvergrpropsBarrel = "dvergrprops_barrel";

		public static readonly string DvergrpropsBed = "dvergrprops_bed";

		public static readonly string DvergrpropsChair = "dvergrprops_chair";

		public static readonly string DvergrpropsCrate = "dvergrprops_crate";

		public static readonly string DvergrpropsCrateLong = "dvergrprops_crate_long";

		public static readonly string DvergrpropsCurtain = "dvergrprops_curtain";

		public static readonly string DvergrpropsHooknchain = "dvergrprops_hooknchain";

		public static readonly string DvergrpropsLantern = "dvergrprops_lantern";

		public static readonly string DvergrpropsLanternStanding = "dvergrprops_lantern_standing";

		public static readonly string DvergrpropsPickaxe = "dvergrprops_pickaxe";

		public static readonly string DvergrpropsShelf = "dvergrprops_shelf";

		public static readonly string DvergrpropsStool = "dvergrprops_stool";

		public static readonly string DvergrpropsTable = "dvergrprops_table";

		public static readonly string DvergrpropsWoodBeam = "dvergrprops_wood_beam";

		public static readonly string DvergrpropsWoodFloor = "dvergrprops_wood_floor";

		public static readonly string DvergrpropsWoodPole = "dvergrprops_wood_pole";

		public static readonly string DvergrpropsWoodStair = "dvergrprops_wood_stair";

		public static readonly string DvergrpropsWoodStake = "dvergrprops_wood_stake";

		public static readonly string DvergrpropsWoodStakewall = "dvergrprops_wood_stakewall";

		public static readonly string DvergrpropsWoodWall = "dvergrprops_wood_wall";

		public static readonly string DvergrtownArch = "dvergrtown_arch";

		public static readonly string DvergrtownCreepDoor = "dvergrtown_creep_door";

		public static readonly string DvergrtownSecretdoor = "dvergrtown_secretdoor";

		public static readonly string DvergrtownSlidingdoor = "dvergrtown_slidingdoor";

		public static readonly string DvergrtownStairCornerWoodLeft = "dvergrtown_stair_corner_wood_left";

		public static readonly string DvergrtownWoodBeam = "dvergrtown_wood_beam";

		public static readonly string DvergrtownWoodCrane = "dvergrtown_wood_crane";

		public static readonly string DvergrtownWoodPole = "dvergrtown_wood_pole";

		public static readonly string DvergrtownWoodStake = "dvergrtown_wood_stake";

		public static readonly string DvergrtownWoodStakewall = "dvergrtown_wood_stakewall";

		public static readonly string DvergrtownWoodSupport = "dvergrtown_wood_support";

		public static readonly string DvergrtownWoodWall01 = "dvergrtown_wood_wall01";

		public static readonly string DvergrtownWoodWall02 = "dvergrtown_wood_wall02";

		public static readonly string DvergrtownWoodWall03 = "dvergrtown_wood_wall03";

		public static readonly string Eikthyr = "Eikthyr";

		public static readonly string EikthyrRagdoll = "eikthyr_ragdoll";

		public static readonly string Eikthyrnir = "Eikthyrnir";

		public static readonly string Eitr = "Eitr";

		public static readonly string Eitrrefinery = "eitrrefinery";

		public static readonly string ElderBark = "ElderBark";

		public static readonly string Entrails = "Entrails";

		public static readonly string EventzoneBonemass = "eventzone_bonemass";

		public static readonly string EventzoneEikthyr = "eventzone_eikthyr";

		public static readonly string EventzoneGdking = "eventzone_gdking";

		public static readonly string EventzoneGoblinking = "eventzone_goblinking";

		public static readonly string EventzoneModer = "eventzone_moder";

		public static readonly string EventzoneQueen = "eventzone_queen";

		public static readonly string EvilHeartForest = "EvilHeart_Forest";

		public static readonly string EvilHeartSwamp = "EvilHeart_Swamp";

		public static readonly string Eyescream = "Eyescream";

		public static readonly string Feathers = "Feathers";

		public static readonly string Fenring = "Fenring";

		public static readonly string FenringAttackFlamesAoe = "Fenring_attack_flames_aoe";

		public static readonly string FenringAttackFrostAoe = "Fenring_attack_frost_aoe";

		public static readonly string FenringCultist = "Fenring_Cultist";

		public static readonly string FenringCultistHildir = "Fenring_Cultist_Hildir";

		public static readonly string FenringCultistHildirNochest = "Fenring_Cultist_Hildir_nochest";

		public static readonly string FenringCultistRagdoll = "Fenring_cultist_ragdoll";

		public static readonly string FenringCultistRagdollHildir = "Fenring_cultist_ragdoll_hildir";

		public static readonly string FenringRagdoll = "Fenring_ragdoll";

		public static readonly string FenringIceNovaAoe = "FenringIceNova_aoe";

		public static readonly string FenrirhideHanging = "fenrirhide_hanging";

		public static readonly string FenrirhideHangingDoor = "fenrirhide_hanging_door";

		public static readonly string Fermenter = "fermenter";

		public static readonly string FineWood = "FineWood";

		public static readonly string FirCone = "FirCone";

		public static readonly string FirePit = "fire_pit";

		public static readonly string FirePitHaldor = "fire_pit_haldor";

		public static readonly string FirePitHildir = "fire_pit_hildir";

		public static readonly string FirePitIron = "fire_pit_iron";

		public static readonly string FireFlies = "FireFlies";

		public static readonly string FireHole = "FireHole";

		public static readonly string FireworksRocketBlue = "FireworksRocket_Blue";

		public static readonly string FireworksRocketCyan = "FireworksRocket_Cyan";

		public static readonly string FireworksRocketGreen = "FireworksRocket_Green";

		public static readonly string FireworksRocketPurple = "FireworksRocket_Purple";

		public static readonly string FireworksRocketRed = "FireworksRocket_Red";

		public static readonly string FireworksRocketWhite = "FireworksRocket_White";

		public static readonly string FireworksRocketYellow = "FireworksRocket_Yellow";

		public static readonly string FirTree = "FirTree";

		public static readonly string FirTreeLog = "FirTree_log";

		public static readonly string FirTreeLogHalf = "FirTree_log_half";

		public static readonly string FirTreeOldLog = "FirTree_oldLog";

		public static readonly string FirTreeSapling = "FirTree_Sapling";

		public static readonly string FirTreeSmall = "FirTree_small";

		public static readonly string FirTreeSmallDead = "FirTree_small_dead";

		public static readonly string FirTreeStub = "FirTree_Stub";

		public static readonly string Fish1 = "Fish1";

		public static readonly string Fish10 = "Fish10";

		public static readonly string Fish11 = "Fish11";

		public static readonly string Fish12 = "Fish12";

		public static readonly string Fish2 = "Fish2";

		public static readonly string Fish3 = "Fish3";

		public static readonly string Fish4Cave = "Fish4_cave";

		public static readonly string Fish5 = "Fish5";

		public static readonly string Fish6 = "Fish6";

		public static readonly string Fish7 = "Fish7";

		public static readonly string Fish8 = "Fish8";

		public static readonly string Fish9 = "Fish9";

		public static readonly string FishAndBread = "FishAndBread";

		public static readonly string FishAndBreadUncooked = "FishAndBreadUncooked";

		public static readonly string FishAnglerRaw = "FishAnglerRaw";

		public static readonly string FishCooked = "FishCooked";

		public static readonly string FishingBait = "FishingBait";

		public static readonly string FishingBaitAshlands = "FishingBaitAshlands";

		public static readonly string FishingBaitCave = "FishingBaitCave";

		public static readonly string FishingBaitDeepNorth = "FishingBaitDeepNorth";

		public static readonly string FishingBaitForest = "FishingBaitForest";

		public static readonly string FishingBaitMistlands = "FishingBaitMistlands";

		public static readonly string FishingBaitOcean = "FishingBaitOcean";

		public static readonly string FishingBaitPlains = "FishingBaitPlains";

		public static readonly string FishingBaitSwamp = "FishingBaitSwamp";

		public static readonly string FishingRod = "FishingRod";

		public static readonly string FishingRodFloat = "FishingRodFloat";

		public static readonly string FishingRodFloatProjectile = "FishingRodFloatProjectile";

		public static readonly string FishRaw = "FishRaw";

		public static readonly string FishWraps = "FishWraps";

		public static readonly string FistFenrirClaw = "FistFenrirClaw";

		public static readonly string Flametal = "Flametal";

		public static readonly string FlametalOre = "FlametalOre";

		public static readonly string Flax = "Flax";

		public static readonly string Flies = "Flies";

		public static readonly string Flint = "Flint";

		public static readonly string FlintspearProjectile = "flintspear_projectile";

		public static readonly string FlyingCore = "flying_core";

		public static readonly string Forge = "forge";

		public static readonly string ForgeExt1 = "forge_ext1";

		public static readonly string ForgeExt2 = "forge_ext2";

		public static readonly string ForgeExt3 = "forge_ext3";

		public static readonly string ForgeExt4 = "forge_ext4";

		public static readonly string ForgeExt5 = "forge_ext5";

		public static readonly string ForgeExt6 = "forge_ext6";

		public static readonly string FreezeGland = "FreezeGland";

		public static readonly string FrostCavesShrineReveal = "FrostCavesShrineReveal";

		public static readonly string FulingTrap = "fuling_trap";

		public static readonly string FulingTurret = "fuling_turret";

		public static readonly string FxAbominationArise = "fx_Abomination_arise";

		public static readonly string FxAbominationAriseEnd = "fx_Abomination_arise_end";

		public static readonly string FxAbominationAttackHit = "fx_Abomination_attack_hit";

		public static readonly string FxAbominationAttack1 = "fx_Abomination_attack1";

		public static readonly string FxAbominationAttack1Start = "fx_Abomination_attack1_start";

		public static readonly string FxAbominationAttack1Trailon = "fx_Abomination_attack1_trailon";

		public static readonly string FxAbominationAttack2 = "fx_Abomination_attack2";

		public static readonly string FxAbominationAttack2Lift = "fx_Abomination_attack2_lift";

		public static readonly string FxAbominationAttack2Start = "fx_Abomination_attack2_start";

		public static readonly string FxAbominationAttack3 = "fx_Abomination_attack3";

		public static readonly string FxAbominationAttack3Start = "fx_Abomination_attack3_start";

		public static readonly string FxAltarCrystalDestruction = "fx_altar_crystal_destruction";

		public static readonly string FxArmorStandPick = "fx_ArmorStand_pick";

		public static readonly string FxBabyseekerDeath = "fx_babyseeker_death";

		public static readonly string FxBabyseekerHurt = "fx_babyseeker_hurt";

		public static readonly string FxBackstab = "fx_backstab";

		public static readonly string FxBatDeath = "fx_bat_death";

		public static readonly string FxBatHit = "fx_bat_hit";

		public static readonly string FxBlobtarTarballHit = "fx_blobtar_tarball_hit";

		public static readonly string FxBoarPet = "fx_boar_pet";

		public static readonly string FxBonemassAoeStart = "fx_Bonemass_aoe_start";

		public static readonly string FxChickenBirth = "fx_chicken_birth";

		public static readonly string FxChickenDeath = "fx_chicken_death";

		public static readonly string FxChickenLayEgg = "fx_chicken_lay_egg";

		public static readonly string FxChickenPet = "fx_chicken_pet";

		public static readonly string FxCreatureTamed = "fx_creature_tamed";

		public static readonly string FxCrit = "fx_crit";

		public static readonly string FxCrystalDestruction = "fx_crystal_destruction";

		public static readonly string FxDeathsquitoHit = "fx_deathsquito_hit";

		public static readonly string FxDeatsquitoDeath = "fx_deatsquito_death";

		public static readonly string FxDragonLand = "fx_dragon_land";

		public static readonly string FxDrown = "fx_drown";

		public static readonly string FxDvergerDeath = "fx_Dverger_death";

		public static readonly string FxDvergerHit = "fx_Dverger_hit";

		public static readonly string FxDvergerMageFireHit = "fx_DvergerMage_Fire_hit";

		public static readonly string FxDvergerMageIceHit = "fx_DvergerMage_Ice_hit";

		public static readonly string FxDvergerMageMistileAttack = "fx_DvergerMage_Mistile_attack";

		public static readonly string FxDvergerMageMistileDie = "fx_DvergerMage_Mistile_die";

		public static readonly string FxDvergerMageMistileSpawn = "fx_DvergerMage_MistileSpawn";

		public static readonly string FxDvergerMageNovaRing = "fx_DvergerMage_Nova_ring";

		public static readonly string FxDvergerMageSupportHit = "fx_DvergerMage_Support_hit";

		public static readonly string FxDvergerMageSupportStart = "fx_DvergerMage_Support_start";

		public static readonly string FxEggSplash = "fx_egg_splash";

		public static readonly string FxEikthyrForwardshockwave = "fx_eikthyr_forwardshockwave";

		public static readonly string FxEikthyrStomp = "fx_eikthyr_stomp";

		public static readonly string FxFenringBurningHand = "fx_fenring_burning_hand";

		public static readonly string FxFenringBurningHandLong = "fx_fenring_burning_hand_long";

		public static readonly string FxFenringFlames = "fx_fenring_flames";

		public static readonly string FxFenringFrost = "fx_fenring_frost";

		public static readonly string FxFenringFrostHand = "fx_fenring_frost_hand";

		public static readonly string FxFenringFrostHandAoestart = "fx_fenring_frost_hand_aoestart";

		public static readonly string FxFenringFrostHandLong = "fx_fenring_frost_hand_long";

		public static readonly string FxFenringIcenova = "fx_fenring_icenova";

		public static readonly string FxFireballStaffExplosion = "fx_fireball_staff_explosion";

		public static readonly string FxFireskeletonNova = "fx_fireskeleton_nova";

		public static readonly string FxFloatHitwater = "fx_float_hitwater";