using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AuthoritativeConfig;
using BalrondHumanoidRandomizer;
using BalrondShipyard;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CapeAndTorchResistanceChanges;
using ClayBuildPieces.Functions;
using CreatureManager;
using HarmonyLib;
using ItemManager;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using LotusEcarlateChanges.Changes.JotunnBased;
using LotusEcarlateChanges.Changes.Manual;
using LotusEcarlateChanges.Changes.StandaloneManagerBased;
using LotusEcarlateChanges.Extensions;
using LotusEcarlateChanges.Model.Changes;
using LotusEcarlateChanges.Model.Managers;
using LotusEcarlateChanges.Model.Managers.Jotunn;
using LotusEcarlateChanges.Model.Managers.Manual;
using LotusEcarlateChanges.Model.Managers.Standalone;
using LotusEcarlateChanges.Model.Wrappers;
using LotusEcarlateChanges.Model.Wrappers.Nested;
using Microsoft.CodeAnalysis;
using PieceManager;
using SpeedyPaths;
using TMPro;
using UnityEngine;
using Valheim.FallDamageForCreatures;
using VentureValheim.Progression;
using Warfare;
using neobotics.ValheimMods;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("BalrondContainers")]
[assembly: IgnoresAccessChecksTo("BalrondHumanoidRandomizer")]
[assembly: IgnoresAccessChecksTo("BalrondShipyard")]
[assembly: IgnoresAccessChecksTo("CapeAndTorchResistanceChanges")]
[assembly: IgnoresAccessChecksTo("ClayBuildPieces")]
[assembly: IgnoresAccessChecksTo("Clutter")]
[assembly: IgnoresAccessChecksTo("CoreWoodPieces")]
[assembly: IgnoresAccessChecksTo("DarkWoodFurnitures")]
[assembly: IgnoresAccessChecksTo("FineWoodBuildPieces")]
[assembly: IgnoresAccessChecksTo("FineWoodFurnitures")]
[assembly: IgnoresAccessChecksTo("Jotunn")]
[assembly: IgnoresAccessChecksTo("MaxAxe")]
[assembly: IgnoresAccessChecksTo("Microsoft.CSharp")]
[assembly: IgnoresAccessChecksTo("Monstrum")]
[assembly: IgnoresAccessChecksTo("MoreGatesExtended")]
[assembly: IgnoresAccessChecksTo("RefinedStonePieces")]
[assembly: IgnoresAccessChecksTo("SimpleElevators")]
[assembly: IgnoresAccessChecksTo("SouthsilArmor")]
[assembly: IgnoresAccessChecksTo("SpeedyPaths")]
[assembly: IgnoresAccessChecksTo("System.Data.DataSetExtensions")]
[assembly: IgnoresAccessChecksTo("Valheim.FallDamageForCreatures")]
[assembly: IgnoresAccessChecksTo("VentureValheim.Progression")]
[assembly: IgnoresAccessChecksTo("Warfare")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyCompany("LotusEcarlateChanges")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.7.6.0")]
[assembly: AssemblyInformationalVersion("0.7.6+4316870492a33f692efd540b045c14bda10ef005")]
[assembly: AssemblyProduct("LotusEcarlateChanges")]
[assembly: AssemblyTitle("LotusEcarlateChanges")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.7.6.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LotusEcarlateChanges
{
	[BepInPlugin("nbusseneau.LotusEcarlateChanges", "LotusEcarlateChanges", "0.7.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string ModGUID = "nbusseneau.LotusEcarlateChanges";

		private const string ModName = "LotusEcarlateChanges";

		private const string ModVersion = "0.7.6";

		public static ManualLogSource Logger { get; private set; }

		public static Harmony Harmony { get; } = new Harmony("nbusseneau.LotusEcarlateChanges");


		public void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			List<IChanges> list = new List<IChanges>(26);
			list.Add(new Clutter());
			list.Add(new CustomSkills());
			list.Add(new MoreGates());
			list.Add(new ClayBuildPieces());
			list.Add(new CoreWoodPieces());
			list.Add(new DarkWoodFurnitures());
			list.Add(new FineWoodBuildPieces());
			list.Add(new FineWoodFurnitures());
			list.Add(new Monstrum());
			list.Add(new RefinedStonePieces());
			list.Add(new SimpleElevators());
			list.Add(new SouthsilArmor());
			list.Add(new Warfare());
			list.Add(new BalrondContainers());
			list.Add(new BalrondHumanoidRandomizer());
			list.Add(new BalrondShipyard());
			list.Add(new CapeAndTorchResistanceChanges());
			list.Add(new CustomKeyHints());
			list.Add(new FallDamageForCreatures());
			list.Add(new Lightsources());
			list.Add(new SpeedyPaths());
			list.Add(new Tutorials());
			list.Add(new VanillaMisc());
			list.Add(new VanillaArmors());
			list.Add(new VanillaWeapons());
			list.Add(new WorldAdvancementProgression());
			list.ForEach(delegate(IChanges changes)
			{
				changes.Apply();
			});
		}
	}
}
namespace LotusEcarlateChanges.Model.Wrappers
{
	public class ItemWrapper : PrefabWrapperBase
	{
		private Recipe _recipe;

		private ResourcesWrapper _resources;

		private readonly ArmorWrapper _armor;

		private readonly FoodWrapper _food;

		private readonly SetWrapper _set;

		private readonly WeaponWrapper _weapon;

		public ItemData ItemData { get; }

		public SharedData SharedData { get; }

		public PieceTable PieceTable { get; }

		public List<GameObject> Pieces { get; }

		public Recipe Recipe
		{
			get
			{
				if (_recipe != null)
				{
					return _recipe;
				}
				Recipe recipe = ObjectDB.instance.GetRecipe(ItemData);
				if (recipe != null)
				{
					return _recipe = recipe;
				}
				return null;
			}
		}

		public ResourcesWrapper Resources
		{
			get
			{
				if (_resources != null)
				{
					return _resources;
				}
				if (Recipe != null)
				{
					return _resources = new ResourcesWrapper(Recipe);
				}
				return null;
			}
		}

		public Sprite Icon => ItemData.GetIcon();

		public ArmorWrapper Armor
		{
			get
			{
				return _armor;
			}
			set
			{
				_armor.CopyProperties(value);
			}
		}

		public FoodWrapper Food
		{
			get
			{
				return _food;
			}
			set
			{
				_food.CopyProperties(value);
			}
		}

		public SetWrapper Set
		{
			get
			{
				return _set;
			}
			set
			{
				_set.CopyProperties(value);
			}
		}

		public WeaponWrapper Weapon
		{
			get
			{
				return _weapon;
			}
			set
			{
				_weapon.CopyProperties(value);
			}
		}

		protected ItemWrapper(GameObject prefab)
			: base(prefab)
		{
			ItemData = base.Prefab.GetComponent<ItemDrop>().m_itemData;
			SharedData = ItemData.m_shared;
			PieceTable = SharedData.m_buildPieces;
			Pieces = PieceTable?.m_pieces;
			_armor = new ArmorWrapper(SharedData);
			_food = new FoodWrapper(SharedData);
			_set = new SetWrapper(SharedData);
			_weapon = new WeaponWrapper(SharedData);
		}

		public static ItemWrapper Get(GameObject prefab)
		{
			if (prefab == null)
			{
				return null;
			}
			if (!PrefabWrapperBase.s_wrappersCache.TryGetValue(((Object)prefab).name, out var value))
			{
				PrefabWrapperBase prefabWrapperBase2 = (PrefabWrapperBase.s_wrappersCache[((Object)prefab).name] = new ItemWrapper(prefab));
				value = prefabWrapperBase2;
			}
			return (ItemWrapper)value;
		}
	}
	public class PieceWrapper : PrefabWrapperBase
	{
		private readonly ComfortWrapper _comfort;

		public Piece Piece { get; }

		public CraftingStation CraftingStation
		{
			get
			{
				return Piece.m_craftingStation;
			}
			set
			{
				Piece.m_craftingStation = value;
			}
		}

		public PieceCategory Category
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return Piece.m_category;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				Piece.m_category = value;
			}
		}

		public ComfortWrapper Comfort
		{
			get
			{
				return _comfort;
			}
			set
			{
				_comfort.CopyProperties(value);
			}
		}

		public ResourcesWrapper Resources { get; }

		protected PieceWrapper(GameObject prefab)
			: base(prefab)
		{
			Piece = base.Prefab.GetComponent<Piece>();
			_comfort = new ComfortWrapper(Piece);
			Resources = new ResourcesWrapper(Piece);
		}

		public static PieceWrapper Get(GameObject prefab)
		{
			if (prefab == null)
			{
				return null;
			}
			if (!PrefabWrapperBase.s_wrappersCache.TryGetValue(((Object)prefab).name, out var value))
			{
				PrefabWrapperBase prefabWrapperBase2 = (PrefabWrapperBase.s_wrappersCache[((Object)prefab).name] = new PieceWrapper(prefab));
				value = prefabWrapperBase2;
			}
			return (PieceWrapper)value;
		}
	}
	public abstract class PrefabWrapperBase
	{
		protected static readonly Dictionary<string, PrefabWrapperBase> s_wrappersCache = new Dictionary<string, PrefabWrapperBase>();

		public GameObject Prefab { get; }

		public string PrefabName => ((Object)Prefab).name;

		protected PrefabWrapperBase(GameObject prefab)
		{
			Prefab = prefab;
			base..ctor();
		}
	}
}
namespace LotusEcarlateChanges.Model.Wrappers.Nested
{
	public class ArmorWrapper
	{
		private readonly SharedData _sharedData;

		public float ArmorBase
		{
			get
			{
				return _sharedData.m_armor;
			}
			set
			{
				_sharedData.m_armor = value;
			}
		}

		public float ArmorPerLevel
		{
			get
			{
				return _sharedData.m_armorPerLevel;
			}
			set
			{
				_sharedData.m_armorPerLevel = value;
			}
		}

		public List<DamageModPair> DamageModifiers
		{
			get
			{
				return _sharedData.m_damageModifiers;
			}
			set
			{
				_sharedData.m_damageModifiers = value;
			}
		}

		public float MovementModifier
		{
			get
			{
				return _sharedData.m_movementModifier;
			}
			set
			{
				_sharedData.m_movementModifier = value;
			}
		}

		public float EitrRegenModifier
		{
			get
			{
				return _sharedData.m_eitrRegenModifier;
			}
			set
			{
				_sharedData.m_eitrRegenModifier = value;
			}
		}

		public float Weight
		{
			get
			{
				return _sharedData.m_weight;
			}
			set
			{
				_sharedData.m_weight = value;
			}
		}

		public SE_Stats EquipEffect
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				return (SE_Stats)_sharedData.m_equipStatusEffect;
			}
			set
			{
				_sharedData.m_equipStatusEffect = (StatusEffect)(object)value;
			}
		}

		public ArmorWrapper(SharedData sharedData)
		{
			_sharedData = sharedData;
			base..ctor();
		}
	}
	public class ComfortWrapper
	{
		private readonly Piece _piece;

		public int Value
		{
			get
			{
				return _piece.m_comfort;
			}
			set
			{
				_piece.m_comfort = value;
			}
		}

		public ComfortGroup Group
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _piece.m_comfortGroup;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				_piece.m_comfortGroup = value;
			}
		}

		public ComfortWrapper(Piece piece)
		{
			_piece = piece;
			base..ctor();
		}
	}
	public class FoodWrapper
	{
		private readonly SharedData _sharedData;

		public float Health
		{
			get
			{
				return _sharedData.m_food;
			}
			set
			{
				_sharedData.m_food = value;
			}
		}

		public float Stamina
		{
			get
			{
				return _sharedData.m_foodStamina;
			}
			set
			{
				_sharedData.m_foodStamina = value;
			}
		}

		public float Eitr
		{
			get
			{
				return _sharedData.m_foodEitr;
			}
			set
			{
				_sharedData.m_foodEitr = value;
			}
		}

		public float Duration
		{
			get
			{
				return _sharedData.m_foodBurnTime;
			}
			set
			{
				_sharedData.m_foodBurnTime = value;
			}
		}

		public float Regen
		{
			get
			{
				return _sharedData.m_foodRegen;
			}
			set
			{
				_sharedData.m_foodRegen = value;
			}
		}

		public FoodWrapper(SharedData sharedData)
		{
			_sharedData = sharedData;
			base..ctor();
		}
	}
	public class ResourcesWrapper
	{
		private readonly Piece _piece;

		private readonly Recipe _recipe;

		private readonly Dictionary<string, Requirement> _resources;

		public ResourcesWrapper(Piece piece)
		{
			_piece = piece;
			_resources = piece.m_resources.ToDictionary((Requirement r) => ((Object)r.m_resItem).name);
		}

		public ResourcesWrapper(Recipe recipe)
		{
			_recipe = recipe;
			_resources = recipe.m_resources.ToDictionary((Requirement r) => ((Object)r.m_resItem).name);
		}

		private void Save()
		{
			int num;
			Requirement[] array;
			if (_piece != null)
			{
				Piece piece = _piece;
				Dictionary<string, Requirement>.ValueCollection values = _resources.Values;
				num = 0;
				array = (Requirement[])(object)new Requirement[values.Count];
				foreach (Requirement item in values)
				{
					array[num] = item;
					num++;
				}
				piece.m_resources = array;
			}
			if (_recipe == null)
			{
				return;
			}
			Recipe recipe = _recipe;
			Dictionary<string, Requirement>.ValueCollection values2 = _resources.Values;
			num = 0;
			array = (Requirement[])(object)new Requirement[values2.Count];
			foreach (Requirement item2 in values2)
			{
				array[num] = item2;
				num++;
			}
			recipe.m_resources = array;
		}

		private void Add(string itemName, int amount)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (!_resources.TryGetValue(itemName, out var value))
			{
				value = new Requirement
				{
					m_resItem = ObjectDB.instance.GetItemPrefab(itemName).GetComponent<ItemDrop>()
				};
				_resources[itemName] = value;
			}
			value.m_amount = amount;
		}

		public void Add(string itemName, int amount, bool recover = true)
		{
			Add(itemName, amount);
			_resources[itemName].m_recover = recover;
			Save();
		}

		public void Add(string itemName, int amount, int amountPerLevel)
		{
			Add(itemName, amount);
			_resources[itemName].m_amountPerLevel = amountPerLevel;
			Save();
		}

		public void Clear()
		{
			_resources.Clear();
			Save();
		}
	}
	public class SetWrapper
	{
		private readonly SharedData _sharedData;

		public SE_Stats Effect
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				return (SE_Stats)_sharedData.m_setStatusEffect;
			}
			set
			{
				_sharedData.m_setStatusEffect = (StatusEffect)(object)value;
			}
		}

		public string Name
		{
			get
			{
				return _sharedData.m_setName;
			}
			set
			{
				_sharedData.m_setName = value;
				if (Effect != null)
				{
					((Object)Effect).name = "SetEffect_" + value;
				}
			}
		}

		public int Size
		{
			get
			{
				return _sharedData.m_setSize;
			}
			set
			{
				_sharedData.m_setSize = value;
			}
		}

		public SetWrapper(SharedData sharedData)
		{
			_sharedData = sharedData;
			base..ctor();
		}
	}
	public class WeaponWrapper
	{
		private readonly SharedData _sharedData;

		public DamageTypes Damages
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _sharedData.m_damages;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				_sharedData.m_damages = value;
			}
		}

		public DamageTypes DamagesPerLevel
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _sharedData.m_damagesPerLevel;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				_sharedData.m_damagesPerLevel = value;
			}
		}

		public float Knockback
		{
			get
			{
				return _sharedData.m_attackForce;
			}
			set
			{
				_sharedData.m_attackForce = value;
			}
		}

		public float BackstabBonus
		{
			get
			{
				return _sharedData.m_backstabBonus;
			}
			set
			{
				_sharedData.m_backstabBonus = value;
			}
		}

		public Attack PrimaryAttack
		{
			get
			{
				return _sharedData.m_attack;
			}
			set
			{
				_sharedData.m_attack = value;
			}
		}

		public Attack SecondaryAttack
		{
			get
			{
				return _sharedData.m_secondaryAttack;
			}
			set
			{
				_sharedData.m_secondaryAttack = value;
			}
		}

		public SE_Stats AttackEffect
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				return (SE_Stats)_sharedData.m_attackStatusEffect;
			}
			set
			{
				_sharedData.m_attackStatusEffect = (StatusEffect)(object)value;
			}
		}

		public float BlockArmor
		{
			get
			{
				return _sharedData.m_blockPower;
			}
			set
			{
				_sharedData.m_blockPower = value;
			}
		}

		public float BlockArmorPerLevel
		{
			get
			{
				return _sharedData.m_blockPowerPerLevel;
			}
			set
			{
				_sharedData.m_blockPowerPerLevel = value;
			}
		}

		public float BlockForce
		{
			get
			{
				return _sharedData.m_deflectionForce;
			}
			set
			{
				_sharedData.m_deflectionForce = value;
			}
		}

		public float BlockForcePerLevel
		{
			get
			{
				return _sharedData.m_deflectionForcePerLevel;
			}
			set
			{
				_sharedData.m_deflectionForcePerLevel = value;
			}
		}

		public float ParryBonus
		{
			get
			{
				return _sharedData.m_timedBlockBonus;
			}
			set
			{
				_sharedData.m_timedBlockBonus = value;
			}
		}

		public float MovementModifier
		{
			get
			{
				return _sharedData.m_movementModifier;
			}
			set
			{
				_sharedData.m_movementModifier = value;
			}
		}

		public float Weight
		{
			get
			{
				return _sharedData.m_weight;
			}
			set
			{
				_sharedData.m_weight = value;
			}
		}

		public SkillType SkillType
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _sharedData.m_skillType;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				_sharedData.m_skillType = value;
			}
		}

		public SE_Stats EquipEffect
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				return (SE_Stats)_sharedData.m_equipStatusEffect;
			}
			set
			{
				_sharedData.m_equipStatusEffect = (StatusEffect)(object)value;
			}
		}

		public WeaponWrapper(SharedData sharedData)
		{
			_sharedData = sharedData;
			base..ctor();
		}
	}
}
namespace LotusEcarlateChanges.Model.Managers
{
	public interface IIndexableManager<T> : IManager, IEnumerable<T>, IEnumerable
	{
		T this[string name] { get; }

		IEnumerable<T> this[params string[] names] { get; }
	}
	public interface IManager
	{
		void Remove(params string[] names);

		void Remove(IEnumerable<string> names);

		void Keep(params string[] names);

		void Keep(IEnumerable<string> names);

		void Apply();
	}
}
namespace LotusEcarlateChanges.Model.Managers.Standalone
{
	public class CreatureManager<T> : PrefabManagerBase<T>, IIndexableManager<T>, IManager, IEnumerable<T>, IEnumerable
	{
		public T this[string name] => GetObject(name);

		public IEnumerable<T> this[params string[] names] => from name in names
			select this[name] into c
			where c != null
			select c;

		public CreatureManager(List<T> registeredCreatures, List<GameObject> prefabs)
			: base(registeredCreatures, prefabs)
		{
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _registeredObjects.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class ItemManager<T> : PrefabManagerBase<T>, IIndexableManager<(T Item, ItemWrapper Wrapper)>, IManager, IEnumerable<(T Item, ItemWrapper Wrapper)>, IEnumerable
	{
		private readonly List<GameObject> _zNetOnlyPrefabs;

		public (T Item, ItemWrapper Wrapper) this[string name]
		{
			get
			{
				T @object = GetObject(name);
				return (@object, ItemWrapper.Get(GetPrefab(@object)));
			}
		}

		public IEnumerable<(T Item, ItemWrapper Wrapper)> this[params string[] names] => from name in names
			select this[name] into t
			where t.Item != null
			select t;

		public ItemManager(List<T> registeredItems, List<GameObject> prefabs, List<GameObject> zNetOnlyPrefabs)
		{
			_zNetOnlyPrefabs = zNetOnlyPrefabs;
			base..ctor(registeredItems, prefabs);
		}

		protected override void ApplyToRemove()
		{
			base.ApplyToRemove();
			_zNetOnlyPrefabs.RemoveAll((GameObject prefab) => _toRemove.Contains(((Object)prefab).name));
		}

		protected override void ApplyToKeep()
		{
			base.ApplyToKeep();
			_zNetOnlyPrefabs.RemoveAll((GameObject prefab) => !_toKeep.Contains(((Object)prefab).name));
		}

		public IEnumerator<(T Item, ItemWrapper Wrapper)> GetEnumerator()
		{
			return _registeredObjects.Select((T obj) => (obj, ItemWrapper.Get(GetPrefab(obj)))).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class LocationManager<T> : StandaloneManagerBase<T>, IIndexableManager<T>, IManager, IEnumerable<T>, IEnumerable
	{
		public T this[string name] => GetObject(name);

		public IEnumerable<T> this[params string[] names] => from name in names
			select this[name] into l
			where l != null
			select l;

		public LocationManager(List<T> registeredLocations)
			: base(registeredLocations)
		{
		}

		protected override string GetName(T location)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			return ((Object)(Location)AccessTools.Field(location.GetType(), "location").GetValue(location)).name;
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _registeredObjects.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class PieceManager<T> : PrefabManagerBase<T>, IIndexableManager<(T BuildPiece, PieceWrapper Wrapper)>, IManager, IEnumerable<(T BuildPiece, PieceWrapper Wrapper)>, IEnumerable
	{
		public (T BuildPiece, PieceWrapper Wrapper) this[string name]
		{
			get
			{
				T @object = GetObject(name);
				return (@object, PieceWrapper.Get(GetPrefab(@object)));
			}
		}

		public IEnumerable<(T BuildPiece, PieceWrapper Wrapper)> this[params string[] names] => from name in names
			select this[name] into t
			where t.BuildPiece != null
			select t;

		public PieceManager(List<T> registeredPieces, List<GameObject> piecePrefabs)
			: base(registeredPieces, piecePrefabs)
		{
		}

		public IEnumerator<(T BuildPiece, PieceWrapper Wrapper)> GetEnumerator()
		{
			return _registeredObjects.Select((T obj) => (obj, PieceWrapper.Get(GetPrefab(obj)))).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public abstract class PrefabManagerBase<T> : StandaloneManagerBase<T>
	{
		protected readonly List<GameObject> _prefabs;

		protected PrefabManagerBase(List<T> registeredObjects, List<GameObject> prefabs)
		{
			_prefabs = prefabs;
			base..ctor(registeredObjects);
		}

		protected GameObject GetPrefab(T obj)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (obj == null)
			{
				return null;
			}
			return (GameObject)AccessTools.Field(obj.GetType(), "Prefab").GetValue(obj);
		}

		protected override string GetName(T obj)
		{
			GameObject prefab = GetPrefab(obj);
			if (prefab == null)
			{
				return null;
			}
			return ((Object)prefab).name;
		}

		protected override void ApplyToRemove()
		{
			base.ApplyToRemove();
			_prefabs.RemoveAll((GameObject prefab) => _toRemove.Contains(((Object)prefab).name));
		}

		protected override void ApplyToKeep()
		{
			base.ApplyToKeep();
			_prefabs.RemoveAll((GameObject prefab) => !_toKeep.Contains(((Object)prefab).name));
		}
	}
	public abstract class StandaloneManagerBase<T> : IManager
	{
		protected readonly List<T> _registeredObjects;

		protected readonly Dictionary<string, T> _objectsCache;

		protected readonly HashSet<string> _toRemove;

		protected readonly HashSet<string> _toKeep;

		protected StandaloneManagerBase(List<T> registeredObjects)
		{
			_registeredObjects = registeredObjects;
			_objectsCache = new Dictionary<string, T>();
			_toRemove = new HashSet<string>();
			_toKeep = new HashSet<string>();
			base..ctor();
		}

		protected abstract string GetName(T obj);

		protected T GetObject(string name, bool logError = true)
		{
			if (!_objectsCache.TryGetValue(name, out var value))
			{
				value = _registeredObjects.SingleOrDefault((T obj) => GetName(obj) == name);
				if (value != null)
				{
					_objectsCache[name] = value;
				}
				else if (logError)
				{
					Plugin.Logger.LogError((object)$"{GetType()} did not find any object registered with name {name}");
				}
			}
			return value;
		}

		public void Remove(params string[] names)
		{
			_toRemove.UnionWith(names);
		}

		public void Remove(IEnumerable<string> names)
		{
			_toRemove.UnionWith(names);
		}

		public void Keep(params string[] names)
		{
			_toKeep.UnionWith(names);
		}

		public void Keep(IEnumerable<string> names)
		{
			_toKeep.UnionWith(names);
		}

		public void Apply()
		{
			if (_toRemove.Any() && _toKeep.Any())
			{
				Plugin.Logger.LogError((object)"Can't have both object names to remove and object names to keep at the same time.");
			}
			else if (_toRemove.Any())
			{
				ApplyToRemove();
			}
			else if (_toKeep.Any())
			{
				ApplyToKeep();
			}
		}

		protected virtual void ApplyToRemove()
		{
			foreach (string item in _toRemove)
			{
				_registeredObjects.Remove(GetObject(item, logError: false));
			}
		}

		protected virtual void ApplyToKeep()
		{
			IEnumerable<T> objectsToKeep = from name in _toKeep
				select GetObject(name, logError: false) into obj
				where obj != null
				select obj;
			_registeredObjects.RemoveAll((T obj) => !objectsToKeep.Contains(obj));
		}
	}
	public class TherzieCreatureManager<T, Y> : PrefabManagerBase<T>, IIndexableManager<(T Creature, IEnumerable<Y> Spawners)>, IManager, IEnumerable<(T Creature, IEnumerable<Y> Spawners)>, IEnumerable
	{
		private readonly List<Y> _registeredSpawners;

		public (T Creature, IEnumerable<Y> Spawners) this[string name]
		{
			get
			{
				T @object = GetObject(name);
				return (@object, GetSpawners(@object));
			}
		}

		public IEnumerable<(T Creature, IEnumerable<Y> Spawners)> this[params string[] names] => from name in names
			select this[name] into t
			where t.Creature != null
			select t;

		public TherzieCreatureManager(List<T> registeredCreatures, List<Y> registeredSpawners, List<GameObject> prefabs)
		{
			_registeredSpawners = registeredSpawners;
			base..ctor(registeredCreatures, prefabs);
		}

		protected override void ApplyToRemove()
		{
			base.ApplyToRemove();
			_registeredSpawners.RemoveAll((Y spawner) => _toRemove.Contains(GetCreatureName(spawner)));
		}

		protected override void ApplyToKeep()
		{
			base.ApplyToKeep();
			_registeredSpawners.RemoveAll((Y spawner) => !_toKeep.Contains(GetCreatureName(spawner)));
		}

		private string GetCreatureName(Y spawner)
		{
			return GetName((T)(AccessTools.Field(spawner.GetType(), "csCreature")?.GetValue(spawner)));
		}

		private IEnumerable<Y> GetSpawners(T creature)
		{
			return _registeredSpawners.Where((Y spawner) => GetCreatureName(spawner).Equals(GetName(creature)));
		}

		public void RemoveSpawner(Y spawner)
		{
			_registeredSpawners.Remove(spawner);
		}

		public IEnumerator<(T Creature, IEnumerable<Y> Spawners)> GetEnumerator()
		{
			return _registeredObjects.Select((T creature) => (creature, GetSpawners(creature))).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
}
namespace LotusEcarlateChanges.Model.Managers.Manual
{
	public class ItemManager : ManualManagerBase<ItemWrapper>
	{
		private static readonly ItemManager s_instance;

		public static ItemManager Instance { get; } = s_instance ?? (s_instance = new ItemManager());


		private ItemManager()
		{
		}

		protected override ItemWrapper Get(string name)
		{
			ObjectDB instance = ObjectDB.instance;
			return ItemWrapper.Get((instance != null) ? instance.GetItemPrefab(name) : null);
		}

		public override void Apply()
		{
			foreach (string name in _toRemove)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(name);
				if (itemPrefab != null)
				{
					ObjectDB.instance.m_items.RemoveAll((GameObject prefab) => ((Object)prefab).name == name);
					ObjectDB.instance.m_itemByHash.Remove(StringExtensionMethods.GetStableHashCode(name));
					Recipe recipe = ObjectDB.instance.GetRecipe(itemPrefab.GetComponent<ItemDrop>()?.m_itemData);
					if (recipe != null)
					{
						ObjectDB.instance.m_recipes.Remove(recipe);
					}
				}
			}
			RegisterStatusEffects();
		}

		private void RegisterStatusEffects()
		{
			foreach (ItemWrapper value in _wrappersCache.Values)
			{
				RegisterStatusEffect(value.SharedData.m_attackStatusEffect);
				RegisterStatusEffect(value.SharedData.m_consumeStatusEffect);
				RegisterStatusEffect(value.SharedData.m_equipStatusEffect);
				RegisterStatusEffect(value.SharedData.m_setStatusEffect);
			}
		}

		private void RegisterStatusEffect(StatusEffect statusEffect)
		{
			if (statusEffect != null && !Object.op_Implicit((Object)(object)ObjectDB.instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode(((Object)statusEffect).name))))
			{
				ObjectDB.instance.m_StatusEffects.Add(statusEffect);
			}
		}
	}
	public abstract class ManualManagerBase<T> : IIndexableManager<T>, IManager, IEnumerable<T>, IEnumerable where T : PrefabWrapperBase
	{
		protected readonly Dictionary<string, T> _wrappersCache = new Dictionary<string, T>();

		protected readonly HashSet<string> _toRemove = new HashSet<string>();

		public T this[string name]
		{
			get
			{
				if (!_wrappersCache.TryGetValue(name, out var value))
				{
					value = Get(name);
					if (value != null)
					{
						_wrappersCache[name] = value;
					}
					else
					{
						Plugin.Logger.LogError((object)$"{GetType()} did not find any object registered with name {name}");
					}
				}
				return value;
			}
		}

		public IEnumerable<T> this[params string[] names] => from name in names
			select this[name] into p
			where p != null
			select p;

		protected abstract T Get(string name);

		public void Remove(params string[] names)
		{
			_toRemove.UnionWith(names);
		}

		public void Remove(IEnumerable<string> names)
		{
			_toRemove.UnionWith(names);
		}

		public void Keep(params string[] names)
		{
			throw new NotSupportedException();
		}

		public void Keep(IEnumerable<string> names)
		{
			throw new NotSupportedException();
		}

		public abstract void Apply();

		public IEnumerator<T> GetEnumerator()
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			throw new NotSupportedException();
		}
	}
	public class PieceManager : ManualManagerBase<PieceWrapper>
	{
		private static readonly PieceManager s_instance;

		private static ItemWrapper s_hammer;

		public static PieceManager Instance { get; } = s_instance ?? (s_instance = new PieceManager());


		private PieceManager()
		{
		}

		protected override PieceWrapper Get(string name)
		{
			ZNetScene instance = ZNetScene.instance;
			return PieceWrapper.Get((instance != null) ? instance.GetPrefab(name) : null);
		}

		public override void Apply()
		{
			foreach (string name in _toRemove)
			{
				if (s_hammer == null)
				{
					s_hammer = ItemWrapper.Get(ObjectDB.instance.GetItemPrefab("Hammer"));
				}
				if (ZNetScene.instance.GetPrefab(name) == null)
				{
					continue;
				}
				ZNetScene.instance.m_prefabs.RemoveAll((GameObject prefab) => ((Object)prefab).name == name);
				ZNetScene.instance.m_nonNetViewPrefabs.RemoveAll((GameObject prefab) => ((Object)prefab).name == name);
				ZNetScene.instance.m_namedPrefabs.Remove(StringExtensionMethods.GetStableHashCode(name));
				s_hammer.Pieces.RemoveAll((GameObject prefab) => ((Object)prefab).name == name);
				foreach (List<Piece> availablePiece in s_hammer.PieceTable.m_availablePieces)
				{
					availablePiece.RemoveAll((Piece piece) => ((Object)piece).name == name);
				}
			}
		}
	}
}
namespace LotusEcarlateChanges.Model.Managers.Jotunn
{
	public class ItemManager : JotunnManagerBase, IIndexableManager<ItemWrapper>, IManager, IEnumerable<ItemWrapper>, IEnumerable
	{
		private static readonly ItemManager s_manager = ItemManager.Instance;

		private readonly IEnumerable<ItemWrapper> _items = from item in ModRegistry.GetItems(modGuid)
			select ItemWrapper.Get(item.ItemPrefab);

		public ItemWrapper this[string name]
		{
			get
			{
				CustomItem item = s_manager.GetItem(name);
				if (item == null)
				{
					Plugin.Logger.LogError((object)$"{GetType()} did not find any object registered with name {name}");
				}
				return ItemWrapper.Get((item != null) ? item.ItemPrefab : null);
			}
		}

		public IEnumerable<ItemWrapper> this[params string[] names] => from name in names
			select this[name] into w
			where w != null
			select w;

		public ItemManager(string modGuid)
		{
		}

		protected override void ApplyToRemove()
		{
			foreach (string item in s_manager.Items.Keys.Where(_toRemove.Contains).ToList())
			{
				s_manager.RemoveItem(item);
			}
		}

		protected override void ApplyToKeep()
		{
			foreach (string item in s_manager.Items.Keys.Where((string itemName) => !_toRemove.Contains(itemName)).ToList())
			{
				s_manager.RemoveItem(item);
			}
		}

		public IEnumerator<ItemWrapper> GetEnumerator()
		{
			return _items.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public abstract class JotunnManagerBase : IManager
	{
		protected readonly HashSet<string> _toRemove = new HashSet<string>();

		protected readonly HashSet<string> _toKeep = new HashSet<string>();

		public void Remove(params string[] names)
		{
			_toRemove.UnionWith(names);
		}

		public void Remove(IEnumerable<string> names)
		{
			_toRemove.UnionWith(names);
		}

		public void Keep(params string[] names)
		{
			_toKeep.UnionWith(names);
		}

		public void Keep(IEnumerable<string> names)
		{
			_toKeep.UnionWith(names);
		}

		public void Apply()
		{
			if (_toRemove.Any() && _toKeep.Any())
			{
				Plugin.Logger.LogError((object)"Can't have both object names to remove and object names to keep at the same time.");
			}
			else if (_toRemove.Any())
			{
				ApplyToRemove();
			}
			else if (_toKeep.Any())
			{
				ApplyToKeep();
			}
		}

		protected abstract void ApplyToRemove();

		protected abstract void ApplyToKeep();
	}
	public class PieceManager : JotunnManagerBase, IIndexableManager<PieceWrapper>, IManager, IEnumerable<PieceWrapper>, IEnumerable
	{
		private static readonly PieceManager s_manager = PieceManager.Instance;

		private readonly IEnumerable<PieceWrapper> _pieces = from piece in ModRegistry.GetPieces(modGuid)
			select PieceWrapper.Get(piece.PiecePrefab);

		public PieceWrapper this[string name]
		{
			get
			{
				CustomPiece piece = s_manager.GetPiece(name);
				if (piece == null)
				{
					Plugin.Logger.LogError((object)$"{GetType()} did not find any object registered with name {name}");
				}
				return PieceWrapper.Get((piece != null) ? piece.PiecePrefab : null);
			}
		}

		public IEnumerable<PieceWrapper> this[params string[] names] => from name in names
			select this[name] into w
			where w != null
			select w;

		public PieceManager(string modGuid)
		{
		}

		protected override void ApplyToRemove()
		{
			foreach (string item in s_manager.Pieces.Keys.Where(_toRemove.Contains).ToList())
			{
				s_manager.RemovePiece(item);
			}
		}

		protected override void ApplyToKeep()
		{
			foreach (string item in s_manager.Pieces.Keys.Where((string itemName) => !_toRemove.Contains(itemName)).ToList())
			{
				s_manager.RemovePiece(item);
			}
		}

		public IEnumerator<PieceWrapper> GetEnumerator()
		{
			return _pieces.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
}
namespace LotusEcarlateChanges.Model.Changes
{
	public interface IChanges
	{
		void Apply();
	}
	public abstract class JotunnBasedChangesBase : IChanges
	{
		protected LotusEcarlateChanges.Model.Managers.Jotunn.ItemManager ItemManager { get; } = (!string.IsNullOrEmpty(modGuid)) ? new LotusEcarlateChanges.Model.Managers.Jotunn.ItemManager(modGuid) : null;


		protected LotusEcarlateChanges.Model.Managers.Jotunn.PieceManager PieceManager { get; } = (!string.IsNullOrEmpty(modGuid)) ? new LotusEcarlateChanges.Model.Managers.Jotunn.PieceManager(modGuid) : null;


		protected JotunnBasedChangesBase(string modGuid = null)
		{
		}

		public void Apply()
		{
			ApplyInternal();
			ItemManager?.Apply();
			PieceManager?.Apply();
			PieceManager.OnPiecesRegistered += ApplyOnPiecesRegisteredInternal;
		}

		protected abstract void ApplyInternal();

		protected virtual void ApplyOnPiecesRegisteredInternal()
		{
		}
	}
	public abstract class ManualChangesBase : IChanges
	{
		private static readonly HashSet<ManualChangesBase> s_instances;

		protected LotusEcarlateChanges.Model.Managers.Manual.ItemManager ItemManager => LotusEcarlateChanges.Model.Managers.Manual.ItemManager.Instance;

		protected LotusEcarlateChanges.Model.Managers.Manual.PieceManager PieceManager => LotusEcarlateChanges.Model.Managers.Manual.PieceManager.Instance;

		public void Apply()
		{
			s_instances.Add(this);
			ApplyInternal();
		}

		protected virtual void ApplyInternal()
		{
		}

		protected static void ApplyOnObjectDBAwake()
		{
			if (ObjectDB.instance.GetItemPrefab("Wood") == null)
			{
				return;
			}
			foreach (ManualChangesBase s_instance in s_instances)
			{
				s_instance.ApplyOnObjectDBAwakeInternal();
			}
			LotusEcarlateChanges.Model.Managers.Manual.ItemManager.Instance.Apply();
			LotusEcarlateChanges.Model.Managers.Manual.PieceManager.Instance.Apply();
		}

		protected virtual void ApplyOnObjectDBAwakeInternal()
		{
		}

		static ManualChangesBase()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			s_instances = new HashSet<ManualChangesBase>();
			Plugin.Harmony.Patch((MethodBase)AccessTools.Method(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(ManualChangesBase), "ApplyOnObjectDBAwake", (Type[])null)
			{
				priority = -100
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	public abstract class StandaloneManagerBasedChangesBase : IChanges
	{
		protected List<IManager> _managers { get; } = new List<IManager>();


		protected ItemManager<T> RegisterItemManager<T>(List<T> registeredItems, List<GameObject> prefabs, List<GameObject> zNetOnlyPrefabs)
		{
			ItemManager<T> itemManager = new ItemManager<T>(registeredItems, prefabs, zNetOnlyPrefabs);
			_managers.Add(itemManager);
			return itemManager;
		}

		protected PieceManager<T> RegisterPieceManager<T>(List<T> registeredPieces, List<GameObject> piecePrefabs)
		{
			PieceManager<T> pieceManager = new PieceManager<T>(registeredPieces, piecePrefabs);
			_managers.Add(pieceManager);
			return pieceManager;
		}

		protected CreatureManager<T> RegisterCreatureManager<T>(List<T> registeredPieces, List<GameObject> prefabs)
		{
			CreatureManager<T> creatureManager = new CreatureManager<T>(registeredPieces, prefabs);
			_managers.Add(creatureManager);
			return creatureManager;
		}

		protected TherzieCreatureManager<T, Y> RegisterCreatureManager<T, Y>(List<T> registeredPieces, List<Y> registeredSpawners, List<GameObject> prefabs)
		{
			TherzieCreatureManager<T, Y> therzieCreatureManager = new TherzieCreatureManager<T, Y>(registeredPieces, registeredSpawners, prefabs);
			_managers.Add(therzieCreatureManager);
			return therzieCreatureManager;
		}

		protected LocationManager<T> RegisterLocationManager<T>(List<T> registeredLocations)
		{
			LocationManager<T> locationManager = new LocationManager<T>(registeredLocations);
			_managers.Add(locationManager);
			return locationManager;
		}

		public void Apply()
		{
			ApplyInternal();
			_managers.ForEach(delegate(IManager manager)
			{
				manager.Apply();
			});
		}

		protected abstract void ApplyInternal();
	}
}
namespace LotusEcarlateChanges.Extensions
{
	public static class GameObjectExtensions
	{
		private static readonly int s_itemLayer = LayerMask.NameToLayer("item");

		public static void FixItemLayer(this GameObject gameObject)
		{
			((Component)gameObject.GetComponentInChildren<Collider>()).gameObject.layer = s_itemLayer;
		}

		public static GameObject Find(this GameObject gameObject, string name)
		{
			return ((Component)gameObject.transform.Find(name)).gameObject;
		}

		public static void SetText(this GameObject gameObject, string text)
		{
			((TMP_Text)gameObject.GetComponentInChildren<TextMeshProUGUI>()).SetText(text);
		}
	}
	public static class GenericTypeExtensions
	{
		public static void CopyProperties<T>(this T targetObject, T sourceObject)
		{
			foreach (PropertyInfo item in from p in targetObject.GetType().GetProperties()
				where p.CanWrite
				select p)
			{
				item.SetValue(targetObject, item.GetValue(sourceObject));
			}
		}
	}
	public static class KeyCodeExtensions
	{
		public static string ToLocalizableString(this KeyCode keyCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ZInput.KeyCodeToDisplayName(keyCode);
		}
	}
	public static class KeyValuePairExtensions
	{
		public static void Deconstruct<T1, T2>(this KeyValuePair<T1, T2> tuple, out T1 key, out T2 value)
		{
			key = tuple.Key;
			value = tuple.Value;
		}
	}
}
namespace LotusEcarlateChanges.Changes
{
	public static class Constants
	{
		public static class Weapon
		{
			public static class MovementModifier
			{
				public const float Knife = 0f;

				public const float Fist = 0f;

				public const float OneHanded = -0.05f;

				public const float TwoHanded = -0.1f;

				public const float Buckler = -0.05f;

				public const float Shield = -0.05f;

				public const float TowerShield = -0.1f;
			}

			public static class ParryBonus
			{
				public const float TowerShield = 1.1f;
			}
		}

		public static class Armor
		{
			public static class VeryLight
			{
				public static class MovementModifier
				{
					public const float Helm = 0f;

					public const float Chest = -0.01f;

					public const float Legs = -0.01f;
				}

				public static class Weight
				{
					public const float Helm = 1f;

					public const float Chest = 6f;

					public const float Legs = 3f;
				}
			}

			public static class SemiLight
			{
				public static class MovementModifier
				{
					public const float Helm = 0f;

					public const float Chest = -0.04f;

					public const float Legs = -0.02f;
				}

				public static class Weight
				{
					public const float Helm = 3f;

					public const float Chest = 10f;

					public const float Legs = 5f;
				}
			}

			public static class Normal
			{
				public static class MovementModifier
				{
					public const float Helm = -0.01f;

					public const float Chest = -0.06f;

					public const float Legs = -0.03f;
				}

				public static class Weight
				{
					public const float Helm = 4f;

					public const float Chest = 12f;

					public const float Legs = 6f;
				}
			}

			public static class Heavy
			{
				public static class MovementModifier
				{
					public const float Helm = -0.02f;

					public const float Chest = -0.08f;

					public const float Legs = -0.04f;
				}

				public static class Weight
				{
					public const float Helm = 5f;

					public const float Chest = 15f;

					public const float Legs = 10f;
				}
			}

			public static class VeryHeavy
			{
				public static class MovementModifier
				{
					public const float Helm = -0.02f;

					public const float Chest = -0.1f;

					public const float Legs = -0.06f;
				}

				public static class Weight
				{
					public const float Helm = 6f;

					public const float Chest = 18f;

					public const float Legs = 12f;
				}
			}
		}
	}
}
namespace LotusEcarlateChanges.Changes.StandaloneManagerBased
{
	public class ClayBuildPieces : StandaloneManagerBasedChangesBase
	{
		protected override void ApplyInternal()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			PieceManager<BuildPiece> pieceManager = RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs);
			pieceManager.Remove("BFP_ClayArmorStand", "BFP_ClayChest");
			foreach (var item3 in pieceManager)
			{
				BuildPiece item = item3.BuildPiece;
				if (item.Category.custom == "ClayBuildPieces")
				{
					item.Category.Set((BuildPieceCategory)2);
				}
				if ((int)item.Category.Category == 0)
				{
					item.Category.Set((BuildPieceCategory)4);
				}
			}
			BuildPiece item2 = pieceManager["BCP_ClayCollector"].BuildPiece;
			item2.Category.Set((BuildPieceCategory)1);
			item2.RequiredItems.Requirements.Clear();
			item2.RequiredItems.Add("Stone", 20, true);
			item2.RequiredItems.Add("Bronze", 10, true);
			item2.RequiredItems.Add("FineWood", 20, true);
			item2.RequiredItems.Add("SurtlingCore", 5, true);
			item2.RequiredItems.Add("BFP_Clay", 30, true);
			string[] names = new string[3] { "BFP_ClayCorgi", "BFP_ClayDeer", "BFP_ClayHare" };
			foreach (var item4 in pieceManager[names])
			{
				item4.Wrapper.Comfort.Value = 0;
			}
			Plugin.Harmony.Patch((MethodBase)AccessTools.Method(typeof(SetupPrefabs), "SetupArmorStand", (Type[])null, (Type[])null), new HarmonyMethod(GetType(), "NoOpPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void NoOpPrefix(ref bool __runOriginal)
		{
			__runOriginal = false;
		}
	}
	public class CoreWoodPieces : StandaloneManagerBasedChangesBase
	{
		protected override void ApplyInternal()
		{
			PieceManager<BuildPiece> pieceManager = RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs);
			pieceManager.Remove("BCW_CoreWood_Fence1", "BCW_CoreWood_Fence2", "BCW_CoreWood_FenceGate", "BCW_CoreWood_FencePillar");
			HashSet<string> hashSet = new HashSet<string> { "BCW_CoreWood_DrawBridgeNarrow", "BCW_CoreWood_DrawBridgeNarrowTall", "BCW_CoreWood_DrawBridgeWide", "BCW_CoreWood_DrawBridgeWideTall" };
			foreach (var item2 in pieceManager)
			{
				BuildPiece item = item2.BuildPiece;
				if (hashSet.Contains(((Object)item.Prefab).name))
				{
					item.Category.Set((BuildPieceCategory)2);
				}
				else if (item.Category.custom == "CoreWoodFence")
				{
					item.Category.Set((BuildPieceCategory)0);
				}
				else if (item.Category.custom == "CoreWoodPieces")
				{
					item.Category.Set((BuildPieceCategory)2);
				}
			}
		}
	}
	public class DarkWoodFurnitures : StandaloneManagerBasedChangesBase
	{
		protected override void ApplyInternal()
		{
			PieceManager<BuildPiece> pieceManager = RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs);
			foreach (var item4 in pieceManager)
			{
				item4.BuildPiece.Category.Set((BuildPieceCategory)4);
			}
			string[] names = new string[3] { "BDWF_Chair6", "BDWF_Chair7", "BDWF_MiniTable1" };
			foreach (var item5 in pieceManager[names])
			{
				item5.Wrapper.Comfort.Value = 2;
			}
			string[] names2 = new string[2] { "BDWF_Bed2", "BDWF_Bed3" };
			foreach (var item6 in pieceManager[names2])
			{
				item6.Wrapper.Comfort.Value = 1;
			}
			(string, int, int)[] array = new(string, int, int)[15]
			{
				("BDWF_Cabinet1", 2, 4),
				("BDWF_Cabinet2", 2, 4),
				("BDWF_Cabinet3", 1, 4),
				("BDWF_Cupboard", 3, 3),
				("BDWF_Drawer1", 3, 3),
				("BDWF_Drawer2", 3, 3),
				("BDWF_Drawer3", 2, 4),
				("BDWF_Drawer4", 2, 2),
				("BDWF_Drawer5", 3, 1),
				("BDWF_Drawer6", 3, 1),
				("BDWF_Drawer7", 3, 1),
				("BDWF_Drawer8", 3, 1),
				("BDWF_IronChest", 7, 4),
				("BDWF_LongCrate", 8, 3),
				("BDWF_Table8", 2, 1)
			};
			for (int i = 0; i < array.Length; i++)
			{
				(string, int, int) tuple = array[i];
				string item = tuple.Item1;
				int item2 = tuple.Item2;
				int item3 = tuple.Item3;
				Container component = pieceManager[item].Wrapper.Prefab.GetComponent<Container>();
				component.m_width = item2;
				component.m_height = item3;
			}
			string[] names3 = new string[1] { "BDWF_Table8" };
			foreach (var item7 in pieceManager[names3])
			{
				Object.Destroy((Object)(object)item7.Wrapper.Prefab.GetComponent<Container>());
			}
		}
	}
	public class FineWoodBuildPieces : StandaloneManagerBasedChangesBase
	{
		protected override void ApplyInternal()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			PieceManager<BuildPiece> pieceManager = RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs);
			pieceManager.Remove("BFP_FenceGate", "BFP_FencePillar1", "BFP_FencePillar2", "BFP_FencePillar3", "BFP_FencePillar4", "BFP_StepLadder1", "BFP_StepLadder2");
			foreach (var item3 in pieceManager)
			{
				BuildPiece item = item3.BuildPiece;
				if ((int)item.Category.Category == 0)
				{
					item.Category.Set((BuildPieceCategory)4);
				}
				else if (item.Category.custom == "FineWoodFence")
				{
					item.Category.Set((BuildPieceCategory)0);
				}
				else if (item.Category.custom == "FineWoodPieces")
				{
					item.Category.Set((BuildPieceCategory)2);
				}
			}
			pieceManager["BFP_HeavyGate"].BuildPiece.Crafting.Set((CraftingTable)3);
			string[] names = new string[9] { "BFP_StoneLightPost", "BFP_StoneRoof26", "BFP_StoneRoof45", "BFP_StoneRoofICorner26", "BFP_StoneRoofICorner45", "BFP_StoneRoofOCorner26", "BFP_StoneRoofOCorner45", "BFP_StoneRoofTop26", "BFP_StoneRoofTop45" };
			foreach (var item4 in pieceManager[names])
			{
				BuildPiece item2 = item4.BuildPiece;
				item2.Crafting.Set((CraftingTable)5);
				item2.Category.Set((BuildPieceCategory)3);
			}
		}
	}
	public class FineWoodFurnitures : StandaloneManagerBasedChangesBase
	{
		protected override void ApplyInternal()
		{
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			PieceManager<BuildPiece> pieceManager = RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs);
			pieceManager.Remove("BFP_ArmorStand", "BFP_WoodenArmorStand");
			foreach (var item6 in pieceManager)
			{
				item6.BuildPiece.Category.Set((BuildPieceCategory)4);
			}
			string[] names = new string[5] { "BFP_FineWoodChair6", "BFP_FineWoodChair7", "BFP_MiniTable1", "BFP_LoxBed", "BFP_LoxDoubleBed" };
			foreach (var item7 in pieceManager[names])
			{
				item7.Wrapper.Comfort.Value = 2;
			}
			string[] names2 = new string[2] { "BFP_FineWoodBed2", "BFP_LeatherBed" };
			foreach (var item8 in pieceManager[names2])
			{
				item8.Wrapper.Comfort.Value = 1;
			}
			string[] names3 = new string[19]
			{
				"BFP_Plant1", "BFP_Plant2", "BFP_Plant3", "BFP_Plant4", "BFP_Plant5", "BFP_Plant6", "BFP_Plant7", "BFP_Plant8", "BFP_Plant9", "BFP_Plant10",
				"BFP_Plant11", "BFP_Plant12", "BFP_Plant13", "BFP_Plant14", "BFP_Plant15", "BFP_Plant16", "BFP_Plant17", "BFP_Plant18", "BFP_FineWoodCrib"
			};
			foreach (var item9 in pieceManager[names3])
			{
				item9.Wrapper.Comfort.Value = 0;
			}
			(string, int, int, int)[] array = new(string, int, int, int)[16]
			{
				("BFP_BronzeFrameChest", 6, 3, 12),
				("BFP_Cabinet1", 2, 4, 12),
				("BFP_Cabinet2", 2, 4, 12),
				("BFP_Cabinet3", 1, 2, 8),
				("BFP_Cabinet4", 3, 3, 16),
				("BFP_Cabinet5", 3, 3, 12),
				("BFP_Cabinet6", 2, 4, 10),
				("BFP_Cabinet7", 3, 4, 12),
				("BFP_Cupboard", 3, 3, 16),
				("BFP_FineWoodBasket", 2, 2, 6),
				("BFP_FineWoodDrawer1", 2, 2, 8),
				("BFP_FineWoodDrawer2", 3, 1, 8),
				("BFP_FineWoodDrawer3", 3, 1, 8),
				("BFP_FineWoodDrawer4", 3, 1, 10),
				("BFP_FineWoodDrawer5", 3, 1, 8),
				("BFP_LongCrate", 7, 2, 12)
			};
			for (int i = 0; i < array.Length; i++)
			{
				(string, int, int, int) tuple = array[i];
				string item = tuple.Item1;
				int item2 = tuple.Item2;
				int item3 = tuple.Item3;
				int item4 = tuple.Item4;
				(BuildPiece BuildPiece, PieceWrapper Wrapper) tuple2 = pieceManager[item];
				BuildPiece item5 = tuple2.BuildPiece;
				Container component = tuple2.Wrapper.Prefab.GetComponent<Container>();
				component.m_width = item2;
				component.m_height = item3;
				Requirement[] array2 = item5.RequiredItems.Requirements.ToArray();
				item5.RequiredItems.Requirements.Clear();
				Requirement[] array3 = array2;
				foreach (Requirement val in array3)
				{
					if (val.itemName == "FineWood")
					{
						item5.RequiredItems.Add(val.itemName, item4, val.recover);
					}
					else
					{
						item5.RequiredItems.Add(val.itemName, val.amount, val.recover);
					}
				}
			}
			string[] names4 = new string[1] { "BFP_FineWoodTable8" };
			foreach (var item10 in pieceManager[names4])
			{
				Object.Destroy((Object)(object)item10.Wrapper.Prefab.GetComponent<Container>());
			}
		}
	}
	public class Monstrum : StandaloneManagerBasedChangesBase
	{
		private TherzieCreatureManager<Creature, Spawner> creatureManager;

		protected override void ApplyInternal()
		{
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0614: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Unknown result type (might be due to invalid IL or missing references)
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0719: Unknown result type (might be due to invalid IL or missing references)
			//IL_0746: Unknown result type (might be due to invalid IL or missing references)
			//IL_074b: Unknown result type (might be due to invalid IL or missing references)
			ItemManager<Item> itemManager = RegisterItemManager(Item.registeredItems, PrefabManager.prefabs, PrefabManager.ZnetOnlyPrefabs);
			PieceManager<BuildPiece> pieceManager = RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs);
			creatureManager = RegisterCreatureManager(Creature.registeredCreatures, Creature.registeredSpawners, PrefabManager.prefabs);
			var (val, pieceWrapper) = pieceManager["rug_Fox_TW"];
			val.RequiredItems.Requirements.Clear();
			val.RequiredItems.Add("FoxPelt_TW", 4, true);
			val.Category.Set((BuildPieceCategory)4);
			pieceWrapper.Comfort.Value = 1;
			pieceWrapper.Comfort.Group = (ComfortGroup)6;
			var (val2, pieceWrapper2) = pieceManager["rug_Rotten_TW"];
			val2.RequiredItems.Requirements.Clear();
			val2.RequiredItems.Add("RottenPelt_TW", 4, true);
			val2.Category.Set((BuildPieceCategory)4);
			pieceWrapper2.Comfort = pieceWrapper.Comfort;
			var (val3, pieceWrapper3) = pieceManager["rug_BlackBear_TW"];
			val3.RequiredItems.Requirements.Clear();
			val3.RequiredItems.Add("BlackBearPelt_TW", 4, true);
			val3.Category.Set((BuildPieceCategory)4);
			pieceWrapper3.Comfort = pieceWrapper.Comfort;
			var (val4, pieceWrapper4) = pieceManager["rug_GrizzlyBear_TW"];
			val4.RequiredItems.Requirements.Clear();
			val4.RequiredItems.Add("GrizzlyBearPelt_TW", 4, true);
			val4.Category.Set((BuildPieceCategory)4);
			pieceWrapper4.Comfort = pieceWrapper.Comfort;
			Item item = itemManager["SaddleBoar_TW"].Item;
			item.Crafting.Stations.Clear();
			item.Crafting.Add((CraftingTable)2, 2);
			item.RequiredItems.Requirements.Clear();
			item.RequiredItems.Add("RazorbackLeather_TW", 10, 0);
			item.RequiredItems.Add("RazorbackTusk_TW", 5, 0);
			item.RequiredItems.Add("Bronze", 10, 0);
			Item item2 = itemManager["SaddleBear_TW"].Item;
			item2.Crafting.Stations.Clear();
			item2.Crafting.Add((CraftingTable)2, 3);
			item2.RequiredItems.Requirements.Clear();
			item2.RequiredItems.Add("BlackBearPelt_TW", 5, 0);
			item2.RequiredItems.Add("GrizzlyBearPelt_TW", 3, 0);
			item2.RequiredItems.Add("Silver", 10, 0);
			Item item3 = itemManager["SaddleProwler_TW"].Item;
			item3.Crafting.Stations.Clear();
			item3.Crafting.Add((CraftingTable)2, 4);
			item3.RequiredItems.Requirements.Clear();
			item3.RequiredItems.Add("ProwlerFang_TW", 2, 0);
			item3.RequiredItems.Add("LinenThread", 20, 0);
			item3.RequiredItems.Add("LoxPelt", 4, 0);
			item3.RequiredItems.Add("BlackMetal", 10, 0);
			ItemWrapper item4 = itemManager["CookedBearSteak_TW"].Wrapper;
			item4.Food.Stamina = 13f;
			item4.Food.Duration = 1200f;
			ItemWrapper item5 = itemManager["MixedGrill_TW"].Wrapper;
			item5.Food.Health = 70f;
			item5.Food.Stamina = 23f;
			creatureManager["BossAsmodeus_TW"].Creature.Drops.drops.Remove("KnifeViper_TW");
			creatureManager["BossSvalt_TW"].Creature.Drops.drops.Remove("DualAxeDemonic_TW");
			creatureManager["BossVrykolathas_TW"].Creature.Drops.drops.Remove("ScytheVampiric_TW");
			creatureManager["BossVrykolathas_TW"].Creature.Drops.drops.Remove("DualScytheBloodthirst_TW");
			creatureManager["Fox_TW"].Creature.Drops["FoxMeat_TW"].DropChance = 100f;
			creatureManager["Razorback_TW"].Creature.Drops["RawMeat"].Amount = new Range(1f, 2f);
			creatureManager["Razorback_TW"].Creature.Drops["RawMeat"].DropChance = 100f;
			creatureManager["BlackBear_TW"].Creature.Drops["BearSteak_TW"].DropChance = 100f;
			creatureManager["GrizzlyBear_TW"].Creature.Drops["GrizzlyBearPelt_TW"].DropChance = 100f;
			creatureManager["GrizzlyBear_TW"].Creature.Drops["BearSteak_TW"].DropChance = 100f;
			creatureManager["Prowler_TW"].Creature.Drops["ProwlerFang_TW"].DropChance = 100f;
			List<Spawner> list = creatureManager["Fox_TW"].Spawners.ToList();
			Spawner val5 = list[0];
			Spawner obj = list[1];
			Spawner obj2 = val5;
			obj2.SpecificSpawnTime = (SpawnTime)0;
			obj2.CheckSpawnInterval = 600;
			obj2.SpawnChance = 10f;
			obj2.Maximum = 1;
			obj2.CanHaveStars = true;
			obj.SpecificSpawnTime = (SpawnTime)1;
			obj.CheckSpawnInterval = 400;
			obj.SpawnChance = 20f;
			obj.Maximum = 1;
			obj.CanHaveStars = true;
			Spawner obj3 = creatureManager["Razorback_TW"].Spawners.Single();
			obj3.CheckSpawnInterval = 150;
			obj3.SpawnChance = 40f;
			obj3.Maximum = 3;
			obj3.GroupSize = new Range(1f, 2f);
			Spawner obj4 = MergeDualSpawners("BlackBear_TW");
			obj4.CheckSpawnInterval = 900;
			obj4.SpawnChance = 10f;
			Spawner obj5 = MergeDualSpawners("Crawler_TW");
			obj5.CheckSpawnInterval = 900;
			obj5.SpawnChance = 10f;
			creatureManager["ObsidianGolem_TW"].Creature.RequiredAltitude = new Range(120f, 1000f);
			creatureManager["ObsidianGolem_TW"].Spawners.Single().CanHaveStars = false;
			Spawner obj6 = MergeDualSpawners("GrizzlyBear_TW");
			obj6.CheckSpawnInterval = 900;
			obj6.SpawnChance = 10f;
			List<Spawner> list2 = creatureManager["Prowler_TW"].Spawners.ToList();
			val5 = list2[0];
			Spawner obj7 = list2[1];
			Spawner obj8 = val5;
			obj8.SpecificSpawnTime = (SpawnTime)0;
			obj8.CheckSpawnInterval = 900;
			obj8.SpawnChance = 10f;
			obj8.Maximum = 1;
			obj8.CanHaveStars = false;
			obj7.SpecificSpawnTime = (SpawnTime)1;
			obj7.CheckSpawnInterval = 600;
			obj7.SpawnChance = 20f;
			obj7.Maximum = 2;
			obj7.GroupSize = new Range(1f, 2f);
			obj7.CanHaveStars = true;
		}

		private Spawner MergeDualSpawners(string creatureName)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Spawner spawner = creatureManager[creatureName].Spawners.First();
			creatureManager.RemoveSpawner(spawner);
			Spawner obj = creatureManager[creatureName].Spawners.Single();
			obj.SpecificSpawnTime = (SpawnTime)2;
			obj.CanHaveStars = true;
			return obj;
		}
	}
	public class RefinedStonePieces : StandaloneManagerBasedChangesBase
	{
		protected override void ApplyInternal()
		{
			PieceManager<BuildPiece> pieceManager = RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs);
			foreach (var item in pieceManager)
			{
				item.BuildPiece.Category.Set((BuildPieceCategory)3);
			}
			string[] names = new string[3] { "BRP_StoneCorgi", "BRP_StoneDeer", "BRP_StoneHare" };
			foreach (var (val, pieceWrapper) in pieceManager[names])
			{
				val.Category.Set((BuildPieceCategory)4);
				pieceWrapper.Comfort.Value = 0;
			}
			pieceManager["BRP_RefinedStone_Stack"].BuildPiece.Category.Set((BuildPieceCategory)0);
			pieceManager["BRP_RefinedStone_Hearth"].BuildPiece.Category.Set((BuildPieceCategory)4);
			pieceManager["BRP_StoneChest"].BuildPiece.Category.Set((BuildPieceCategory)4);
		}
	}
	public class SimpleElevators : StandaloneManagerBasedChangesBase
	{
		protected override void ApplyInternal()
		{
			foreach (var item2 in RegisterPieceManager(BuildPiece.registeredPieces, PiecePrefabManager.piecePrefabs))
			{
				BuildPiece item = item2.BuildPiece;
				item.Category.Set((BuildPieceCategory)3);
				item.Crafting.Set((CraftingTable)7);
			}
		}
	}
	public class SouthsilArmor : StandaloneManagerBasedChangesBase
	{
		private static readonly List<Action> s_onLocalizationAddedCallbacks = new List<Action>();

		protected override void ApplyInternal()
		{
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b34: Unknown result type (might be due to invalid IL or missing references)
			//IL_1023: Unknown result type (might be due to invalid IL or missing references)
			//IL_102b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1030: Unknown result type (might be due to invalid IL or missing references)
			//IL_1038: Unknown result type (might be due to invalid IL or missing references)
			//IL_103d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1543: Unknown result type (might be due to invalid IL or missing references)
			//IL_1556: Unknown result type (might be due to invalid IL or missing references)
			//IL_155b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1575: Unknown result type (might be due to invalid IL or missing references)
			//IL_157d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1582: Unknown result type (might be due to invalid IL or missing references)
			//IL_158a: Unknown result type (might be due to invalid IL or missing references)
			//IL_158f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a58: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a6c: Unknown result type (might be due to invalid IL or missing references)
			//IL_2023: Unknown result type (might be due to invalid IL or missing references)
			//IL_2037: Unknown result type (might be due to invalid IL or missing references)
			//IL_249a: Unknown result type (might be due to invalid IL or missing references)
			//IL_24ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_24b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_2997: Unknown result type (might be due to invalid IL or missing references)
			//IL_29ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e9f: Unknown result type (might be due to invalid IL or missing references)
			//IL_2ea4: Unknown result type (might be due to invalid IL or missing references)
			//IL_3408: Unknown result type (might be due to invalid IL or missing references)
			//IL_341b: Unknown result type (might be due to invalid IL or missing references)
			//IL_3420: Unknown result type (might be due to invalid IL or missing references)
			//IL_39be: Unknown result type (might be due to invalid IL or missing references)
			//IL_39d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f40: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f54: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f77: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f7f: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f84: Unknown result type (might be due to invalid IL or missing references)
			ItemManager<Item> itemManager = RegisterItemManager(Item.registeredItems, PrefabManager.prefabs, PrefabManager.ZnetOnlyPrefabs);
			LocalizationManager.OnLocalizationAdded += onLocalizationAddedCallback;
			itemManager.Keep("chiefhelmboar", "chiefhelmdeer", "chiefchest", "chieflegs");
			var (chieftainHelmBoar, itemWrapper) = itemManager["chiefhelmboar"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				chieftainHelmBoar.Name.Alias("$SouthsilArmor_ChieftainHelmBoar_Name");
				chieftainHelmBoar.Description.Alias("$SouthsilArmor_ChieftainHelmBoar_Description");
			});
			chieftainHelmBoar.Crafting.Stations.Clear();
			chieftainHelmBoar.Crafting.Add((CraftingTable)2, 2);
			chieftainHelmBoar.RequiredItems.Requirements.Clear();
			chieftainHelmBoar.RequiredItems.Add("DeerHide", 2, 0);
			chieftainHelmBoar.RequiredItems.Add("LeatherScraps", 2, 0);
			chieftainHelmBoar.RequiredItems.Add("FoxPelt_TW", 1, 0);
			chieftainHelmBoar.RequiredItems.Add("TrophyBoar", 2, 0);
			chieftainHelmBoar.RequiredUpgradeItems.Requirements.Clear();
			chieftainHelmBoar.RequiredUpgradeItems.Add("DeerHide", 1, 0);
			chieftainHelmBoar.RequiredUpgradeItems.Add("LeatherScraps", 1, 0);
			itemWrapper.Armor.ArmorBase = 2f;
			itemWrapper.Armor.ArmorPerLevel = 2f;
			itemWrapper.Armor.MovementModifier = -0.01f;
			itemWrapper.Armor.Weight = 4f;
			SE_Stats equipEffect = itemWrapper.Armor.EquipEffect;
			((StatusEffect)equipEffect).m_name = "$SouthsilArmor_ChieftainHelmBoar_Effect_Name";
			((StatusEffect)equipEffect).m_tooltip = "$SouthsilArmor_ChieftainHelmBoar_Effect_Tooltip";
			equipEffect.m_healthRegenMultiplier = 1.25f;
			equipEffect.m_staminaRegenMultiplier = 1f;
			equipEffect.m_skillLevel = (SkillType)6;
			equipEffect.m_skillLevelModifier = 10f;
			chieftainHelmBoar.Prefab.FixItemLayer();
			var (chieftainHelmDeer, itemWrapper2) = itemManager["chiefhelmdeer"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				chieftainHelmDeer.Name.Alias("$SouthsilArmor_ChieftainHelmDeer_Name");
				chieftainHelmDeer.Description.Alias("$SouthsilArmor_ChieftainHelmDeer_Description");
			});
			chieftainHelmDeer.Crafting.Stations.Clear();
			chieftainHelmDeer.Crafting.Add((CraftingTable)2, 2);
			chieftainHelmDeer.RequiredItems.Requirements.Clear();
			chieftainHelmDeer.RequiredItems.Add("DeerHide", 2, 0);
			chieftainHelmDeer.RequiredItems.Add("LeatherScraps", 2, 0);
			chieftainHelmDeer.RequiredItems.Add("FoxPelt_TW", 1, 0);
			chieftainHelmDeer.RequiredItems.Add("TrophyDeer", 2, 0);
			chieftainHelmDeer.RequiredUpgradeItems.Requirements.Clear();
			chieftainHelmDeer.RequiredUpgradeItems.Add("DeerHide", 1, 0);
			chieftainHelmDeer.RequiredUpgradeItems.Add("LeatherScraps", 1, 0);
			itemWrapper2.Armor.ArmorBase = 2f;
			itemWrapper2.Armor.ArmorPerLevel = 2f;
			itemWrapper2.Armor.MovementModifier = -0.01f;
			itemWrapper2.Armor.Weight = 4f;
			SE_Stats equipEffect2 = itemWrapper2.Armor.EquipEffect;
			((StatusEffect)equipEffect2).m_name = "$SouthsilArmor_ChieftainHelmDeer_Effect_Name";
			((StatusEffect)equipEffect2).m_tooltip = "$SouthsilArmor_ChieftainHelmDeer_Effect_Tooltip";
			equipEffect2.m_speedModifier = 0f;
			equipEffect2.m_runStaminaDrainModifier = 0f;
			equipEffect2.m_staminaRegenMultiplier = 1.5f;
			equipEffect2.m_skillLevel = (SkillType)102;
			equipEffect2.m_skillLevelModifier = 10f;
			chieftainHelmDeer.Prefab.FixItemLayer();
			var (chieftainChest, itemWrapper3) = itemManager["chiefchest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				chieftainChest.Name.Alias("$SouthsilArmor_ChieftainChest_Name");
				chieftainChest.Description.Alias("$SouthsilArmor_ChieftainChest_Description");
			});
			chieftainChest.Crafting.Stations.Clear();
			chieftainChest.Crafting.Add((CraftingTable)2, 2);
			chieftainChest.RequiredItems.Requirements.Clear();
			chieftainChest.RequiredItems.Add("DeerHide", 6, 0);
			chieftainChest.RequiredItems.Add("FoxPelt_TW", 3, 0);
			chieftainChest.RequiredItems.Add("ShieldWood", 1, 0);
			chieftainChest.RequiredItems.Add("Feathers", 5, 0);
			chieftainChest.RequiredUpgradeItems.Requirements.Clear();
			chieftainChest.RequiredUpgradeItems.Add("DeerHide", 3, 0);
			chieftainChest.RequiredUpgradeItems.Add("LeatherScraps", 3, 0);
			chieftainChest.RequiredUpgradeItems.Add("FoxPelt_TW", 1, 0);
			itemWrapper3.Armor.ArmorBase = 6f;
			itemWrapper3.Armor.ArmorPerLevel = 3f;
			itemWrapper3.Armor.MovementModifier = -0.06f;
			itemWrapper3.Armor.Weight = 12f;
			var (chieftainLegs, itemWrapper4) = itemManager["chieflegs"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				chieftainLegs.Name.Alias("$SouthsilArmor_ChieftainLegs_Name");
				chieftainLegs.Description.Alias("$SouthsilArmor_ChieftainLegs_Description");
			});
			chieftainLegs.Crafting.Stations.Clear();
			chieftainLegs.Crafting.Add((CraftingTable)2, 2);
			chieftainLegs.RequiredItems.Requirements.Clear();
			chieftainLegs.RequiredItems.Add("DeerHide", 4, 0);
			chieftainLegs.RequiredItems.Add("FoxPelt_TW", 2, 0);
			chieftainLegs.RequiredItems.Add("KnifeFlint", 2, 0);
			chieftainLegs.RequiredItems.Add("AxeFlint", 1, 0);
			chieftainLegs.RequiredUpgradeItems.Requirements.Clear();
			chieftainLegs.RequiredUpgradeItems.Add("DeerHide", 2, 0);
			chieftainLegs.RequiredUpgradeItems.Add("LeatherScraps", 2, 0);
			itemWrapper4.Armor.ArmorBase = 4f;
			itemWrapper4.Armor.ArmorPerLevel = 3f;
			itemWrapper4.Armor.MovementModifier = -0.03f;
			itemWrapper4.Armor.Weight = 6f;
			itemManager.Keep("heavybronzehelm", "heavybronzechest", "heavybronzelegs");
			var (battleswineHelm, itemWrapper5) = itemManager["heavybronzehelm"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				battleswineHelm.Name.Alias("$SouthsilArmor_BattleswineHelm_Name");
				battleswineHelm.Description.Alias("$SouthsilArmor_BattleswineHelm_Description");
			});
			battleswineHelm.Crafting.Stations.Clear();
			battleswineHelm.Crafting.Add((CraftingTable)4, 2);
			battleswineHelm.RequiredItems.Requirements.Clear();
			battleswineHelm.RequiredItems.Add("Bronze", 3, 0);
			battleswineHelm.RequiredItems.Add("RazorbackLeather_TW", 2, 0);
			battleswineHelm.RequiredItems.Add("BlackBearPelt_TW", 1, 0);
			battleswineHelm.RequiredItems.Add("RazorbackTusk_TW", 2, 0);
			battleswineHelm.RequiredUpgradeItems.Requirements.Clear();
			battleswineHelm.RequiredUpgradeItems.Add("Bronze", 2, 0);
			battleswineHelm.RequiredUpgradeItems.Add("RazorbackLeather_TW", 1, 0);
			battleswineHelm.RequiredUpgradeItems.Add("DeerHide", 2, 0);
			battleswineHelm.RequiredUpgradeItems.Add("RazorbackTusk_TW", 1, 0);
			itemWrapper5.Armor.ArmorBase = 6f;
			itemWrapper5.Armor.ArmorPerLevel = 3f;
			itemWrapper5.Armor.MovementModifier = -0.02f;
			itemWrapper5.Armor.Weight = 6f;
			battleswineHelm.Prefab.FixItemLayer();
			var (battleswineChest, itemWrapper6) = itemManager["heavybronzechest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				battleswineChest.Name.Alias("$SouthsilArmor_BattleswineChest_Name");
				battleswineChest.Description.Alias("$SouthsilArmor_BattleswineChest_Description");
			});
			battleswineChest.Crafting.Stations.Clear();
			battleswineChest.Crafting.Add((CraftingTable)4, 2);
			battleswineChest.RequiredItems.Requirements.Clear();
			battleswineChest.RequiredItems.Add("Bronze", 9, 0);
			battleswineChest.RequiredItems.Add("RazorbackLeather_TW", 4, 0);
			battleswineChest.RequiredItems.Add("BlackBearPelt_TW", 3, 0);
			battleswineChest.RequiredItems.Add("TrophyRazorback_TW", 1, 0);
			battleswineChest.RequiredUpgradeItems.Requirements.Clear();
			battleswineChest.RequiredUpgradeItems.Add("Bronze", 5, 0);
			battleswineChest.RequiredUpgradeItems.Add("RazorbackLeather_TW", 1, 0);
			battleswineChest.RequiredUpgradeItems.Add("BlackBearPelt_TW", 1, 0);
			itemWrapper6.Armor.ArmorBase = 18f;
			itemWrapper6.Armor.ArmorPerLevel = 4f;
			itemWrapper6.Armor.MovementModifier = -0.1f;
			itemWrapper6.Armor.Weight = 18f;
			var (battleswineLegs, itemWrapper7) = itemManager["heavybronzelegs"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				battleswineLegs.Name.Alias("$SouthsilArmor_BattleswineLegs_Name");
				battleswineLegs.Description.Alias("$SouthsilArmor_BattleswineLegs_Description");
			});
			battleswineLegs.Crafting.Stations.Clear();
			battleswineLegs.Crafting.Add((CraftingTable)4, 2);
			battleswineLegs.RequiredItems.Requirements.Clear();
			battleswineLegs.RequiredItems.Add("Bronze", 6, 0);
			battleswineLegs.RequiredItems.Add("RazorbackLeather_TW", 2, 0);
			battleswineLegs.RequiredItems.Add("BlackBearPelt_TW", 2, 0);
			battleswineLegs.RequiredUpgradeItems.Requirements.Clear();
			battleswineLegs.RequiredUpgradeItems.Add("Bronze", 4, 0);
			battleswineLegs.RequiredUpgradeItems.Add("RazorbackLeather_TW", 1, 0);
			battleswineLegs.RequiredUpgradeItems.Add("DeerHide", 4, 0);
			itemWrapper7.Armor.ArmorBase = 12f;
			itemWrapper7.Armor.ArmorPerLevel = 3f;
			itemWrapper7.Armor.MovementModifier = -0.06f;
			itemWrapper7.Armor.Weight = 12f;
			SE_Stats val = ScriptableObject.CreateInstance<SE_Stats>();
			((StatusEffect)val).m_name = "$SouthsilArmor_BattleswineSet_Effect_Name";
			((StatusEffect)val).m_tooltip = "$SouthsilArmor_BattleswineSet_Effect_Tooltip";
			((StatusEffect)val).m_icon = itemWrapper5.Icon;
			val.m_skillLevel = (SkillType)5;
			val.m_skillLevelModifier = 15f;
			val.m_skillLevel2 = (SkillType)4;
			val.m_skillLevelModifier2 = 15f;
			itemWrapper5.Set.Effect = val;
			itemWrapper5.Set.Name = "Battleswine";
			itemWrapper5.Set.Size = 3;
			itemWrapper6.Set = itemWrapper5.Set;
			itemWrapper7.Set = itemWrapper5.Set;
			itemManager.Keep("swamphelm", "swampchest", "swamplegs");
			var (draugrHelm, itemWrapper8) = itemManager["swamphelm"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				draugrHelm.Name.Alias("$SouthsilArmor_DraugrHelm_Name");
				draugrHelm.Description.Alias("$SouthsilArmor_DraugrHelm_Description");
			});
			draugrHelm.Crafting.Stations.Clear();
			draugrHelm.Crafting.Add((CraftingTable)4, 3);
			draugrHelm.RequiredItems.Requirements.Clear();
			draugrHelm.RequiredItems.Add("Iron", 15, 0);
			draugrHelm.RequiredItems.Add("RottenPelt_TW", 2, 0);
			draugrHelm.RequiredItems.Add("WitheredBone", 2, 0);
			draugrHelm.RequiredItems.Add("TrophyCrawler_TW", 1, 0);
			draugrHelm.RequiredUpgradeItems.Requirements.Clear();
			draugrHelm.RequiredUpgradeItems.Add("Iron", 4, 0);
			draugrHelm.RequiredUpgradeItems.Add("RottenPelt_TW", 1, 0);
			draugrHelm.RequiredUpgradeItems.Add("WitheredBone", 1, 0);
			itemWrapper8.Armor.ArmorBase = 9f;
			itemWrapper8.Armor.ArmorPerLevel = 3f;
			itemWrapper8.Armor.MovementModifier = -0.02f;
			itemWrapper8.Armor.Weight = 6f;
			draugrHelm.Prefab.FixItemLayer();
			var (draugrChest, itemWrapper9) = itemManager["swampchest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				draugrChest.Name.Alias("$SouthsilArmor_DraugrChest_Name");
				draugrChest.Description.Alias("$SouthsilArmor_DraugrChest_Description");
			});
			draugrChest.Crafting.Stations.Clear();
			draugrChest.Crafting.Add((CraftingTable)4, 3);
			draugrChest.RequiredItems.Requirements.Clear();
			draugrChest.RequiredItems.Add("Iron", 45, 0);
			draugrChest.RequiredItems.Add("RottenPelt_TW", 4, 0);
			draugrChest.RequiredItems.Add("WitheredBone", 8, 0);
			draugrChest.RequiredUpgradeItems.Requirements.Clear();
			draugrChest.RequiredUpgradeItems.Add("Iron", 11, 0);
			draugrChest.RequiredUpgradeItems.Add("RottenPelt_TW", 2, 0);
			draugrChest.RequiredUpgradeItems.Add("WitheredBone", 4, 0);
			itemWrapper9.Armor.ArmorBase = 27f;
			itemWrapper9.Armor.ArmorPerLevel = 4f;
			itemWrapper9.Armor.MovementModifier = -0.1f;
			itemWrapper9.Armor.Weight = 18f;
			var (draugrLegs, itemWrapper10) = itemManager["swamplegs"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				draugrLegs.Name.Alias("$SouthsilArmor_DraugrLegs_Name");
				draugrLegs.Description.Alias("$SouthsilArmor_DraugrLegs_Description");
			});
			draugrLegs.Crafting.Stations.Clear();
			draugrLegs.Crafting.Add((CraftingTable)4, 3);
			draugrLegs.RequiredItems.Requirements.Clear();
			draugrLegs.RequiredItems.Add("Iron", 30, 0);
			draugrLegs.RequiredItems.Add("RottenPelt_TW", 2, 0);
			draugrLegs.RequiredItems.Add("WitheredBone", 4, 0);
			draugrLegs.RequiredItems.Add("TrophySkeleton", 4, 0);
			draugrLegs.RequiredUpgradeItems.Requirements.Clear();
			draugrLegs.RequiredUpgradeItems.Add("Iron", 7, 0);
			draugrLegs.RequiredUpgradeItems.Add("RottenPelt_TW", 1, 0);
			draugrLegs.RequiredUpgradeItems.Add("WitheredBone", 2, 0);
			itemWrapper10.Armor.ArmorBase = 18f;
			itemWrapper10.Armor.ArmorPerLevel = 3f;
			itemWrapper10.Armor.MovementModifier = -0.06f;
			itemWrapper10.Armor.Weight = 12f;
			SE_Stats val2 = ScriptableObject.CreateInstance<SE_Stats>();
			((StatusEffect)val2).m_name = "$SouthsilArmor_DraugrSet_Effect_Name";
			((StatusEffect)val2).m_tooltip = "$SouthsilArmor_DraugrSet_Effect_Tooltip";
			((StatusEffect)val2).m_icon = itemWrapper8.Icon;
			val2.m_mods.Add(new DamageModPair
			{
				m_type = CapeAndTorchResistanceChanges.Water,
				m_modifier = (DamageModifier)3
			});
			itemWrapper8.Set.Effect = val2;
			itemWrapper8.Set.Name = "Draugr";
			itemWrapper8.Set.Size = 3;
			itemWrapper9.Set = itemWrapper8.Set;
			itemWrapper10.Set = itemWrapper8.Set;
			itemManager.Keep("heavybearhelm", "heavybearchest", "heavybearlegs");
			var (grizzlyHelm, itemWrapper11) = itemManager["heavybearhelm"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				grizzlyHelm.Name.Alias("$SouthsilArmor_GrizzlyHelm_Name");
				grizzlyHelm.Description.Alias("$SouthsilArmor_GrizzlyHelm_Description");
			});
			grizzlyHelm.Crafting.Stations.Clear();
			grizzlyHelm.Crafting.Add((CraftingTable)4, 3);
			grizzlyHelm.RequiredItems.Requirements.Clear();
			grizzlyHelm.RequiredItems.Add("Silver", 15, 0);
			grizzlyHelm.RequiredItems.Add("GrizzlyBearPelt_TW", 1, 0);
			grizzlyHelm.RequiredItems.Add("TrophyHatchling", 1, 0);
			grizzlyHelm.RequiredItems.Add("TrophyGrizzlyBear_TW", 1, 0);
			grizzlyHelm.RequiredUpgradeItems.Requirements.Clear();
			grizzlyHelm.RequiredUpgradeItems.Add("Silver", 4, 0);
			grizzlyHelm.RequiredUpgradeItems.Add("WolfPelt", 2, 0);
			itemWrapper11.Armor.ArmorBase = 12f;
			itemWrapper11.Armor.ArmorPerLevel = 3f;
			itemWrapper11.Armor.MovementModifier = -0.02f;
			itemWrapper11.Armor.Weight = 6f;
			grizzlyHelm.Prefab.FixItemLayer();
			var (grizzlyChest, itemWrapper12) = itemManager["heavybearchest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				grizzlyChest.Name.Alias("$SouthsilArmor_GrizzlyChest_Name");
				grizzlyChest.Description.Alias("$SouthsilArmor_GrizzlyChest_Description");
			});
			grizzlyChest.Crafting.Stations.Clear();
			grizzlyChest.Crafting.Add((CraftingTable)4, 3);
			grizzlyChest.RequiredItems.Requirements.Clear();
			grizzlyChest.RequiredItems.Add("Silver", 45, 0);
			grizzlyChest.RequiredItems.Add("GrizzlyBearPelt_TW", 3, 0);
			grizzlyChest.RequiredItems.Add("WolfPelt", 4, 0);
			grizzlyChest.RequiredItems.Add("ClaymoreIron_TW", 1, 0);
			grizzlyChest.RequiredUpgradeItems.Requirements.Clear();
			grizzlyChest.RequiredUpgradeItems.Add("Silver", 11, 0);
			grizzlyChest.RequiredUpgradeItems.Add("GrizzlyBearPelt_TW", 2, 0);
			grizzlyChest.RequiredUpgradeItems.Add("WolfPelt", 2, 0);
			itemWrapper12.Armor.ArmorBase = 36f;
			itemWrapper12.Armor.ArmorPerLevel = 4f;
			itemWrapper12.Armor.MovementModifier = -0.1f;
			itemWrapper12.Armor.Weight = 18f;
			itemWrapper12.SharedData.m_heatResistanceModifier = 0f;
			var (grizzlyLegs, itemWrapper13) = itemManager["heavybearlegs"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				grizzlyLegs.Name.Alias("$SouthsilArmor_GrizzlyLegs_Name");
				grizzlyLegs.Description.Alias("$SouthsilArmor_GrizzlyLegs_Description");
			});
			grizzlyLegs.Crafting.Stations.Clear();
			grizzlyLegs.Crafting.Add((CraftingTable)4, 3);
			grizzlyLegs.RequiredItems.Requirements.Clear();
			grizzlyLegs.RequiredItems.Add("Silver", 30, 0);
			grizzlyLegs.RequiredItems.Add("GrizzlyBearPelt_TW", 2, 0);
			grizzlyLegs.RequiredItems.Add("KnifeSilver", 2, 0);
			grizzlyLegs.RequiredItems.Add("TankardAnniversary", 1, 0);
			grizzlyLegs.RequiredUpgradeItems.Requirements.Clear();
			grizzlyLegs.RequiredUpgradeItems.Add("Silver", 7, 0);
			grizzlyLegs.RequiredUpgradeItems.Add("GrizzlyBearPelt_TW", 1, 0);
			grizzlyLegs.RequiredUpgradeItems.Add("WolfPelt", 2, 0);
			itemWrapper13.Armor.ArmorBase = 24f;
			itemWrapper13.Armor.ArmorPerLevel = 3f;
			itemWrapper13.Armor.MovementModifier = -0.06f;
			itemWrapper13.Armor.Weight = 12f;
			itemWrapper13.SharedData.m_heatResistanceModifier = 0f;
			SE_Stats val3 = ScriptableObject.CreateInstance<SE_Stats>();
			((StatusEffect)val3).m_name = "$SouthsilArmor_GrizzlySet_Effect_Name";
			((StatusEffect)val3).m_tooltip = "$SouthsilArmor_GrizzlySet_Effect_Tooltip";
			((StatusEffect)val3).m_icon = itemWrapper11.Icon;
			val3.m_skillLevel = (SkillType)1;
			val3.m_skillLevelModifier = 15f;
			val3.m_skillLevel2 = CustomSkills.TwoHandedSwords;
			val3.m_skillLevelModifier2 = 15f;
			val3.m_mods.Add(new DamageModPair
			{
				m_type = CapeAndTorchResistanceChanges.Cold,
				m_modifier = (DamageModifier)5
			});
			itemWrapper11.Set.Effect = val3;
			itemWrapper11.Set.Name = "Grizzly";
			itemWrapper11.Set.Size = 3;
			itemWrapper12.Set = itemWrapper11.Set;
			itemWrapper13.Set = itemWrapper11.Set;
			itemManager.Keep("obswolfhelm", "obswolfchest", "obswolflegs");
			var (feralHelm, itemWrapper14) = itemManager["obswolfhelm"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				feralHelm.Name.Alias("$SouthsilArmor_FeralHelm_Name");
				feralHelm.Description.Alias("$SouthsilArmor_FeralHelm_Description");
			});
			feralHelm.Crafting.Stations.Clear();
			feralHelm.Crafting.Add((CraftingTable)4, 2);
			feralHelm.RequiredItems.Requirements.Clear();
			feralHelm.RequiredItems.Add("BlackMetal", 4, 0);
			feralHelm.RequiredItems.Add("WolfHairBundle", 10, 0);
			feralHelm.RequiredItems.Add("TrophyProwler_TW", 1, 0);
			feralHelm.RequiredItems.Add("Ruby", 5, 0);
			feralHelm.RequiredUpgradeItems.Requirements.Clear();
			feralHelm.RequiredUpgradeItems.Add("BlackMetal", 2, 0);
			feralHelm.RequiredUpgradeItems.Add("WolfHairBundle", 5, 0);
			itemWrapper14.Armor.ArmorBase = 7f;
			itemWrapper14.Armor.ArmorPerLevel = 2f;
			itemWrapper14.Armor.MovementModifier = 0f;
			itemWrapper14.Armor.Weight = 1f;
			feralHelm.Prefab.FixItemLayer();
			var (feralChest, itemWrapper15) = itemManager["obswolfchest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				feralChest.Name.Alias("$SouthsilArmor_FeralChest_Name");
				feralChest.Description.Alias("$SouthsilArmor_FeralChest_Description");
			});
			feralChest.Crafting.Stations.Clear();
			feralChest.Crafting.Add((CraftingTable)4, 2);
			feralChest.RequiredItems.Requirements.Clear();
			feralChest.RequiredItems.Add("BlackMetal", 12, 0);
			feralChest.RequiredItems.Add("LoxPelt", 4, 0);
			feralChest.RequiredItems.Add("ProwlerFang_TW", 4, 0);
			feralChest.RequiredItems.Add("TrophyUlv", 4, 0);
			feralChest.RequiredUpgradeItems.Requirements.Clear();
			feralChest.RequiredUpgradeItems.Add("BlackMetal", 6, 0);
			feralChest.RequiredUpgradeItems.Add("LoxPelt", 1, 0);
			feralChest.RequiredUpgradeItems.Add("ProwlerFang_TW", 2, 0);
			itemWrapper15.Armor.ArmorBase = 21f;
			itemWrapper15.Armor.ArmorPerLevel = 3f;
			itemWrapper15.Armor.MovementModifier = -0.01f;
			itemWrapper15.Armor.Weight = 6f;
			itemWrapper15.Armor.DamageModifiers.Clear();
			var (feralLegs, itemWrapper16) = itemManager["obswolflegs"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				feralLegs.Name.Alias("$SouthsilArmor_FeralLegs_Name");
				feralLegs.Description.Alias("$SouthsilArmor_FeralLegs_Description");
			});
			feralLegs.Crafting.Stations.Clear();
			feralLegs.Crafting.Add((CraftingTable)4, 2);
			feralLegs.RequiredItems.Requirements.Clear();
			feralLegs.RequiredItems.Add("BlackMetal", 8, 0);
			feralLegs.RequiredItems.Add("LinenThread", 20, 0);
			feralLegs.RequiredItems.Add("WolfClaw", 5, 0);
			feralLegs.RequiredUpgradeItems.Requirements.Clear();
			feralLegs.RequiredUpgradeItems.Add("BlackMetal", 4, 0);
			feralLegs.RequiredUpgradeItems.Add("LinenThread", 10, 0);
			itemWrapper16.Armor.ArmorBase = 14f;
			itemWrapper16.Armor.ArmorPerLevel = 3f;
			itemWrapper16.Armor.MovementModifier = -0.01f;
			itemWrapper16.Armor.Weight = 3f;
			SE_Stats val4 = ScriptableObject.CreateInstance<SE_Stats>();
			((StatusEffect)val4).m_name = "$SouthsilArmor_FeralSet_Effect_Name";
			((StatusEffect)val4).m_tooltip = "$SouthsilArmor_FeralSet_Effect_Tooltip";
			((StatusEffect)val4).m_icon = itemWrapper14.Icon;
			val4.m_skillLevel = (SkillType)101;
			val4.m_skillLevelModifier = 15f;
			val4.m_skillLevel2 = (SkillType)2;
			val4.m_skillLevelModifier2 = 15f;
			itemWrapper14.Set.Effect = val4;
			itemWrapper14.Set.Name = "Feral";
			itemWrapper14.Set.Size = 3;
			itemWrapper15.Set = itemWrapper14.Set;
			itemWrapper16.Set = itemWrapper14.Set;
			itemManager.Keep("norahhelm", "norahhelmalt", "norahchest", "norahlegs");
			var (shieldmaidenHelm, itemWrapper17) = itemManager["norahhelm"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				shieldmaidenHelm.Name.Alias("$SouthsilArmor_ShieldmaidenHelm_Name");
				shieldmaidenHelm.Description.Alias("$SouthsilArmor_ShieldmaidenHelm_Description");
			});
			shieldmaidenHelm.Crafting.Stations.Clear();
			shieldmaidenHelm.Crafting.Add((CraftingTable)4, 2);
			shieldmaidenHelm.RequiredItems.Requirements.Clear();
			shieldmaidenHelm.RequiredItems.Add("LinenThread", 10, 0);
			shieldmaidenHelm.RequiredItems.Add("Coins", 500, 0);
			shieldmaidenHelm.RequiredUpgradeItems.Requirements.Clear();
			shieldmaidenHelm.RequiredUpgradeItems.Add("LinenThread", 10, 0);
			itemWrapper17.Armor.ArmorBase = 10f;
			itemWrapper17.Armor.ArmorPerLevel = 2f;
			itemWrapper17.Armor.MovementModifier = 0f;
			itemWrapper17.Armor.Weight = 3f;
			var (shieldmaidenHelmAlt, itemWrapper18) = itemManager["norahhelmalt"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				shieldmaidenHelmAlt.Name.Alias("$SouthsilArmor_ShieldmaidenHelmAlt_Name");
				shieldmaidenHelmAlt.Description.Alias("$SouthsilArmor_ShieldmaidenHelmAlt_Description");
			});
			shieldmaidenHelmAlt.Crafting.Stations.Clear();
			shieldmaidenHelmAlt.Crafting.Add((CraftingTable)4, 2);
			shieldmaidenHelmAlt.RequiredItems.Requirements.Clear();
			shieldmaidenHelmAlt.RequiredItems.Add("LinenThread", 10, 0);
			shieldmaidenHelmAlt.RequiredItems.Add("LoxPelt", 1, 0);
			shieldmaidenHelmAlt.RequiredUpgradeItems.Requirements.Clear();
			shieldmaidenHelmAlt.RequiredUpgradeItems.Add("LinenThread", 10, 0);
			itemWrapper18.Armor.ArmorBase = 10f;
			itemWrapper18.Armor.ArmorPerLevel = 2f;
			itemWrapper18.Armor.MovementModifier = 0f;
			itemWrapper18.Armor.Weight = 3f;
			shieldmaidenHelmAlt.Prefab.FixItemLayer();
			var (shieldmaidenChest, itemWrapper19) = itemManager["norahchest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				shieldmaidenChest.Name.Alias("$SouthsilArmor_ShieldmaidenChest_Name");
				shieldmaidenChest.Description.Alias("$SouthsilArmor_ShieldmaidenChest_Description");
			});
			shieldmaidenChest.Crafting.Stations.Clear();
			shieldmaidenChest.Crafting.Add((CraftingTable)4, 2);
			shieldmaidenChest.RequiredItems.Requirements.Clear();
			shieldmaidenChest.RequiredItems.Add("Iron", 12, 0);
			shieldmaidenChest.RequiredItems.Add("LinenThread", 30, 0);
			shieldmaidenChest.RequiredItems.Add("LoxPelt", 4, 0);
			shieldmaidenChest.RequiredItems.Add("KnifeSilver", 1, 0);
			shieldmaidenChest.RequiredUpgradeItems.Requirements.Clear();
			shieldmaidenChest.RequiredUpgradeItems.Add("Iron", 8, 0);
			shieldmaidenChest.RequiredUpgradeItems.Add("LinenThread", 15, 0);
			shieldmaidenChest.RequiredUpgradeItems.Add("LoxPelt", 1, 0);
			itemWrapper19.Armor.ArmorBase = 30f;
			itemWrapper19.Armor.ArmorPerLevel = 3f;
			itemWrapper19.Armor.MovementModifier = -0.04f;
			itemWrapper19.Armor.Weight = 10f;
			var (shieldmaidenLegs, itemWrapper20) = itemManager["norahlegs"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				shieldmaidenLegs.Name.Alias("$SouthsilArmor_ShieldmaidenLegs_Name");
				shieldmaidenLegs.Description.Alias("$SouthsilArmor_ShieldmaidenLegs_Description");
			});
			shieldmaidenLegs.Crafting.Stations.Clear();
			shieldmaidenLegs.Crafting.Add((CraftingTable)4, 2);
			shieldmaidenLegs.RequiredItems.Requirements.Clear();
			shieldmaidenLegs.RequiredItems.Add("Iron", 8, 0);
			shieldmaidenLegs.RequiredItems.Add("LinenThread", 20, 0);
			shieldmaidenLegs.RequiredItems.Add("LoxPelt", 2, 0);
			shieldmaidenLegs.RequiredUpgradeItems.Requirements.Clear();
			shieldmaidenLegs.RequiredUpgradeItems.Add("Iron", 4, 0);
			shieldmaidenLegs.RequiredUpgradeItems.Add("LinenThread", 10, 0);
			shieldmaidenLegs.RequiredUpgradeItems.Add("LoxPelt", 2, 0);
			itemWrapper20.Armor.ArmorBase = 20f;
			itemWrapper20.Armor.ArmorPerLevel = 2f;
			itemWrapper20.Armor.MovementModifier = -0.02f;
			itemWrapper20.Armor.Weight = 5f;
			SE_Stats val5 = ScriptableObject.CreateInstance<SE_Stats>();
			((StatusEffect)val5).m_name = "$SouthsilArmor_ShieldmaidenSet_Effect_Name";
			((StatusEffect)val5).m_tooltip = "$SouthsilArmor_ShieldmaidenSet_Effect_Tooltip";
			((StatusEffect)val5).m_icon = itemWrapper19.Icon;
			val5.m_skillLevel = (SkillType)3;
			val5.m_skillLevelModifier = 15f;
			val5.m_skillLevel2 = (SkillType)6;
			val5.m_skillLevelModifier2 = 15f;
			itemWrapper17.Set.Effect = val5;
			itemWrapper17.Set.Name = "Shieldmaiden";
			itemWrapper17.Set.Size = 3;
			itemWrapper18.Set = itemWrapper17.Set;
			itemWrapper19.Set = itemWrapper17.Set;
			itemWrapper20.Set = itemWrapper17.Set;
			itemManager.Keep("bearhelm2", "bearchest2", "bearlegs2");
			var (berserkirHelm, itemWrapper21) = itemManager["bearhelm2"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				berserkirHelm.Name.Alias("$SouthsilArmor_BerserkirHelm_Name");
				berserkirHelm.Description.Alias("$SouthsilArmor_BerserkirHelm_Description");
			});
			berserkirHelm.Crafting.Stations.Clear();
			berserkirHelm.Crafting.Add((CraftingTable)4, 3);
			berserkirHelm.RequiredItems.Requirements.Clear();
			berserkirHelm.RequiredItems.Add("BlackMetal", 15, 0);
			berserkirHelm.RequiredItems.Add("LinenThread", 10, 0);
			berserkirHelm.RequiredUpgradeItems.Requirements.Clear();
			berserkirHelm.RequiredUpgradeItems.Add("BlackMetal", 7, 0);
			berserkirHelm.RequiredUpgradeItems.Add("LinenThread", 5, 0);
			itemWrapper21.Armor.ArmorBase = 15f;
			itemWrapper21.Armor.ArmorPerLevel = 3f;
			itemWrapper21.Armor.MovementModifier = -0.02f;
			itemWrapper21.Armor.Weight = 6f;
			var (berserkirChest, itemWrapper22) = itemManager["bearchest2"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				berserkirChest.Name.Alias("$SouthsilArmor_BerserkirChest_Name");
				berserkirChest.Description.Alias("$SouthsilArmor_BerserkirChest_Description");
			});
			berserkirChest.Crafting.Stations.Clear();
			berserkirChest.Crafting.Add((CraftingTable)4, 3);
			berserkirChest.RequiredItems.Requirements.Clear();
			berserkirChest.RequiredItems.Add("BlackMetal", 45, 0);
			berserkirChest.RequiredItems.Add("LinenThread", 23, 0);
			berserkirChest.RequiredItems.Add("Chain", 10, 0);
			berserkirChest.RequiredUpgradeItems.Requirements.Clear();
			berserkirChest.RequiredUpgradeItems.Add("BlackMetal", 20, 0);
			berserkirChest.RequiredUpgradeItems.Add("LinenThread", 15, 0);
			itemWrapper22.Armor.ArmorBase = 45f;
			itemWrapper22.Armor.ArmorPerLevel = 4f;
			itemWrapper22.Armor.MovementModifier = -0.1f;
			itemWrapper22.Armor.Weight = 18f;
			var (berserkirLegs, itemWrapper23) = itemManager["bearlegs2"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				berserkirLegs.Name.Alias("$SouthsilArmor_BerserkirLegs_Name");
				berserkirLegs.Description.Alias("$SouthsilArmor_BerserkirLegs_Description");
			});
			berserkirLegs.Crafting.Stations.Clear();
			berserkirLegs.Crafting.Add((CraftingTable)4, 3);
			berserkirLegs.RequiredItems.Requirements.Clear();
			berserkirLegs.RequiredItems.Add("BlackMetal", 30, 0);
			berserkirLegs.RequiredItems.Add("LinenThread", 20, 0);
			berserkirLegs.RequiredUpgradeItems.Requirements.Clear();
			berserkirLegs.RequiredUpgradeItems.Add("BlackMetal", 15, 0);
			berserkirLegs.RequiredUpgradeItems.Add("LinenThread", 10, 0);
			itemWrapper23.Armor.ArmorBase = 30f;
			itemWrapper23.Armor.ArmorPerLevel = 4f;
			itemWrapper23.Armor.MovementModifier = -0.06f;
			itemWrapper23.Armor.Weight = 12f;
			itemWrapper23.Armor.DamageModifiers.Clear();
			SE_Stats val6 = ScriptableObject.CreateInstance<SE_Stats>();
			((StatusEffect)val6).m_name = "$SouthsilArmor_BerserkirSet_Effect_Name";
			((StatusEffect)val6).m_tooltip = "$SouthsilArmor_BerserkirSet_Effect_Tooltip";
			((StatusEffect)val6).m_icon = itemWrapper21.Icon;
			val6.m_skillLevel = (SkillType)4;
			val6.m_skillLevelModifier = 15f;
			val6.m_skillLevel2 = CustomSkills.TwoHandedAxes;
			val6.m_skillLevelModifier2 = 15f;
			itemWrapper21.Set.Effect = val6;
			itemWrapper21.Set.Name = "Berserkir";
			itemWrapper21.Set.Size = 3;
			itemWrapper22.Set = itemWrapper21.Set;
			itemWrapper23.Set = itemWrapper21.Set;
			itemManager.Keep("heavycarhelm", "heavycarchest", "heavycarlegs");
			var (gjallhunterHelm, itemWrapper24) = itemManager["heavycarhelm"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				gjallhunterHelm.Name.Alias("$SouthsilArmor_GjallhunterHelm_Name");
				gjallhunterHelm.Description.Alias("$SouthsilArmor_GjallhunterHelm_Description");
			});
			gjallhunterHelm.Crafting.Stations.Clear();
			gjallhunterHelm.Crafting.Add((CraftingTable)8, 1);
			gjallhunterHelm.RequiredItems.Requirements.Clear();
			gjallhunterHelm.RequiredItems.Add("Carapace", 8, 0);
			gjallhunterHelm.RequiredItems.Add("Mandible", 2, 0);
			gjallhunterHelm.RequiredItems.Add("TrophyGjall", 2, 0);
			gjallhunterHelm.RequiredUpgradeItems.Requirements.Clear();
			gjallhunterHelm.RequiredUpgradeItems.Add("Carapace", 4, 0);
			gjallhunterHelm.RequiredUpgradeItems.Add("Mandible", 1, 0);
			itemWrapper24.Armor.ArmorBase = 12f;
			itemWrapper24.Armor.ArmorPerLevel = 3f;
			itemWrapper24.Armor.MovementModifier = 0f;
			itemWrapper24.Armor.Weight = 3f;
			itemWrapper24.Armor.EquipEffect = null;
			gjallhunterHelm.Prefab.FixItemLayer();
			var (gjallhunterChest, itemWrapper25) = itemManager["heavycarchest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				gjallhunterChest.Name.Alias("$SouthsilArmor_GjallhunterChest_Name");
				gjallhunterChest.Description.Alias("$SouthsilArmor_GjallhunterChest_Description");
			});
			gjallhunterChest.Crafting.Stations.Clear();
			gjallhunterChest.Crafting.Add((CraftingTable)8, 1);
			gjallhunterChest.RequiredItems.Requirements.Clear();
			gjallhunterChest.RequiredItems.Add("Carapace", 20, 0);
			gjallhunterChest.RequiredItems.Add("Mandible", 6, 0);
			gjallhunterChest.RequiredItems.Add("ScaleHide", 10, 0);
			gjallhunterChest.RequiredItems.Add("TrophySkeleton", 4, 0);
			gjallhunterChest.RequiredUpgradeItems.Requirements.Clear();
			gjallhunterChest.RequiredUpgradeItems.Add("Carapace", 10, 0);
			gjallhunterChest.RequiredUpgradeItems.Add("Mandible", 3, 0);
			gjallhunterChest.RequiredUpgradeItems.Add("ScaleHide", 5, 0);
			itemWrapper25.Armor.ArmorBase = 36f;
			itemWrapper25.Armor.ArmorPerLevel = 4f;
			itemWrapper25.Armor.MovementModifier = -0.04f;
			itemWrapper25.Armor.Weight = 10f;
			var (gjallhunterLegs, itemWrapper26) = itemManager["heavycarlegs"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				gjallhunterLegs.Name.Alias("$SouthsilArmor_GjallhunterLegs_Name");
				gjallhunterLegs.Description.Alias("$SouthsilArmor_GjallhunterLegs_Description");
			});
			gjallhunterLegs.Crafting.Stations.Clear();
			gjallhunterLegs.Crafting.Add((CraftingTable)8, 1);
			gjallhunterLegs.RequiredItems.Requirements.Clear();
			gjallhunterLegs.RequiredItems.Add("Carapace", 12, 0);
			gjallhunterLegs.RequiredItems.Add("Mandible", 2, 0);
			gjallhunterLegs.RequiredItems.Add("ScaleHide", 4, 0);
			gjallhunterLegs.RequiredItems.Add("TrophySkeleton", 4, 0);
			gjallhunterLegs.RequiredUpgradeItems.Requirements.Clear();
			gjallhunterLegs.RequiredUpgradeItems.Add("Carapace", 6, 0);
			gjallhunterLegs.RequiredUpgradeItems.Add("Mandible", 1, 0);
			gjallhunterLegs.RequiredUpgradeItems.Add("ScaleHide", 2, 0);
			itemWrapper26.Armor.ArmorBase = 24f;
			itemWrapper26.Armor.ArmorPerLevel = 3f;
			itemWrapper26.Armor.MovementModifier = -0.02f;
			itemWrapper26.Armor.Weight = 5f;
			SE_Stats val7 = ScriptableObject.CreateInstance<SE_Stats>();
			((StatusEffect)val7).m_name = "$SouthsilArmor_GjallhunterSet_Effect_Name";
			((StatusEffect)val7).m_tooltip = "$SouthsilArmor_GjallhunterSet_Effect_Tooltip";
			((StatusEffect)val7).m_icon = itemWrapper24.Icon;
			val7.m_skillLevel = (SkillType)8;
			val7.m_skillLevelModifier = 15f;
			val7.m_skillLevel2 = (SkillType)14;
			val7.m_skillLevelModifier2 = 15f;
			itemWrapper24.Set.Effect = val7;
			itemWrapper24.Set.Name = "Gjallhunter";
			itemWrapper24.Set.Size = 3;
			itemWrapper25.Set = itemWrapper24.Set;
			itemWrapper26.Set = itemWrapper24.Set;
			itemManager.Keep("runeknighthelm", "runeknightchest", "runeknightlegs");
			var (runeknightHelm, itemWrapper27) = itemManager["runeknighthelm"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				runeknightHelm.Name.Alias("$SouthsilArmor_RuneknightHelm_Name");
				runeknightHelm.Description.Alias("$SouthsilArmor_RuneknightHelm_Description");
			});
			runeknightHelm.Crafting.Stations.Clear();
			runeknightHelm.Crafting.Add((CraftingTable)8, 1);
			runeknightHelm.RequiredItems.Requirements.Clear();
			runeknightHelm.RequiredItems.Add("BlackMetal", 10, 0);
			runeknightHelm.RequiredItems.Add("Eitr", 15, 0);
			runeknightHelm.RequiredItems.Add("DarkCrystal_TW", 5, 0);
			runeknightHelm.RequiredUpgradeItems.Requirements.Clear();
			runeknightHelm.RequiredUpgradeItems.Add("BlackMetal", 5, 0);
			runeknightHelm.RequiredUpgradeItems.Add("Eitr", 5, 0);
			itemWrapper27.Armor.ArmorBase = 17f;
			itemWrapper27.Armor.ArmorPerLevel = 3f;
			itemWrapper27.Armor.MovementModifier = -0.02f;
			itemWrapper27.Armor.Weight = 5f;
			runeknightHelm.Prefab.FixItemLayer();
			var (runeknightChest, itemWrapper28) = itemManager["runeknightchest"];
			s_onLocalizationAddedCallbacks.Add(delegate
			{
				runeknightChest.Name.Alias("$SouthsilArmor_RuneknightChest_Name");
				runeknightChest.Description.Alias(