using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using UnityEngine;
using ValheimArmory.common;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValheimArmory")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimArmory")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
namespace ValheimArmory
{
	internal class ValheimArmoryItems
	{
		private AssetBundle EmbeddedResourceBundle = ValheimArmory.EmbeddedResourceBundle;

		public ValheimArmoryItems()
		{
			if (VAConfig.EnableDebugMode.Value)
			{
				Logger.LogInfo((object)"Loading Items.");
			}
			LoadArrows();
			LoadBows();
			LoadSwords();
			LoadAxes();
			LoadHammers();
			LoadAtgeirs();
			LoadDaggers();
			LoadShields();
			LoadSpears();
			LoadMaces();
			LoadFists();
			LoadMagic();
			LoadPickaxes();
			LoadNonCraftables();
		}

		private void LoadArrows()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("name", "Black Metal Arrow");
			dictionary.Add("catagory", "Arrows");
			dictionary.Add("prefab", "VAArrowGreenMetal");
			dictionary.Add("sprite", "arrow_greenmetal");
			dictionary.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"BlackMetal",
					new Tuple<int, int>(2, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			dictionary2.Add("name", "Bone Arrow");
			dictionary2.Add("catagory", "Arrows");
			dictionary2.Add("prefab", "VAArrowBone");
			dictionary2.Add("sprite", "bone_arrow");
			dictionary2.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary2, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(32f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"BoneFragments",
					new Tuple<int, int>(8, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
			dictionary3.Add("name", "Surtling Fire Arrow");
			dictionary3.Add("catagory", "Arrows");
			dictionary3.Add("prefab", "VAarrow_surtling_fire");
			dictionary3.Add("sprite", "surtlingcore_arrow");
			dictionary3.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary3, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"fire",
					new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Obsidian",
					new Tuple<int, int>(4, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				},
				{
					"SurtlingCore",
					new Tuple<int, int>(1, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
			dictionary4.Add("name", "Ancient Wood Arrow");
			dictionary4.Add("catagory", "Arrows");
			dictionary4.Add("prefab", "VAarrowancient");
			dictionary4.Add("sprite", "ancient_arrow");
			dictionary4.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary4, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(37f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"ElderBark",
					new Tuple<int, int>(8, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary5 = new Dictionary<string, string>();
			dictionary5.Add("name", "Chitin Arrow");
			dictionary5.Add("catagory", "Arrows");
			dictionary5.Add("prefab", "VAchitinarrow");
			dictionary5.Add("sprite", "arrow_chitin");
			dictionary5.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary5, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(12f, 0f, 200f, item4: true)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(35f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Chitin",
					new Tuple<int, int>(2, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary6 = new Dictionary<string, string>();
			dictionary6.Add("name", "Wood Bolt");
			dictionary6.Add("catagory", "Arrows");
			dictionary6.Add("prefab", "VABoltWood");
			dictionary6.Add("sprite", "bolt_wood");
			dictionary6.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary6, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(22f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>> { 
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			} }, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary7 = new Dictionary<string, string>();
			dictionary7.Add("name", "Corewood Bolt");
			dictionary7.Add("catagory", "Arrows");
			dictionary7.Add("prefab", "VABoltCoreWood");
			dictionary7.Add("sprite", "bolt_corewood");
			dictionary7.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary7, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(37f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"RoundLog",
					new Tuple<int, int>(8, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary8 = new Dictionary<string, string>();
			dictionary8.Add("name", "Bronze Bolt");
			dictionary8.Add("catagory", "Arrows");
			dictionary8.Add("prefab", "VAbolt_bronze");
			dictionary8.Add("sprite", "bronze_bolt");
			dictionary8.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary8, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(32f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Bronze",
					new Tuple<int, int>(1, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary9 = new Dictionary<string, string>();
			dictionary9.Add("name", "Poison Bolt");
			dictionary9.Add("catagory", "Arrows");
			dictionary9.Add("prefab", "VAbolt_poison");
			dictionary9.Add("sprite", "poison_bolt");
			dictionary9.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary9, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"poison",
					new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Iron",
					new Tuple<int, int>(1, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				},
				{
					"Ooze",
					new Tuple<int, int>(1, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary10 = new Dictionary<string, string>();
			dictionary10.Add("name", "Obsidian Bolt");
			dictionary10.Add("catagory", "Arrows");
			dictionary10.Add("prefab", "VAObsidianBolt");
			dictionary10.Add("sprite", "obsidian_bolt");
			dictionary10.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary10, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Obsidian",
					new Tuple<int, int>(4, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary11 = new Dictionary<string, string>();
			dictionary11.Add("name", "Frost Bolt");
			dictionary11.Add("catagory", "Arrows");
			dictionary11.Add("prefab", "VAbolt_frost");
			dictionary11.Add("sprite", "ice_bolt");
			dictionary11.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary11, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"frost",
					new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(20f, 0f, 200f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Silver",
					new Tuple<int, int>(1, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				},
				{
					"FreezeGland",
					new Tuple<int, int>(1, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary12 = new Dictionary<string, string>();
			dictionary12.Add("name", "Surtling Core Bolt");
			dictionary12.Add("catagory", "Arrows");
			dictionary12.Add("prefab", "VASurtlingBolt");
			dictionary12.Add("sprite", "surtling_bolt");
			dictionary12.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary12, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"fire",
					new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Iron",
					new Tuple<int, int>(1, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				},
				{
					"SurtlingCore",
					new Tuple<int, int>(1, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary13 = new Dictionary<string, string>();
			dictionary13.Add("name", "Needle Bolt");
			dictionary13.Add("catagory", "Arrows");
			dictionary13.Add("prefab", "VABoltNeedle");
			dictionary13.Add("sprite", "needle_bolt");
			dictionary13.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary13, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(56f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Needle",
					new Tuple<int, int>(8, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary14 = new Dictionary<string, string>();
			dictionary14.Add("name", "Fire Bolt");
			dictionary14.Add("catagory", "Arrows");
			dictionary14.Add("prefab", "VAFireBolt");
			dictionary14.Add("sprite", "surtling_bolt");
			dictionary14.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary14, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(22f, 0f, 200f, item4: true)
				},
				{
					"fire",
					new Tuple<float, float, float, bool>(34f, 0f, 200f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Resin",
					new Tuple<int, int>(8, 0)
				},
				{
					"Feathers",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
		}

		private void LoadBows()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("name", "Carapace Blood Bow");
			dictionary.Add("catagory", "Bows");
			dictionary.Add("prefab", "VAHeavy_Blood_Bone_Bow");
			dictionary.Add("sprite", "blood_bone_bow_heavy");
			dictionary.Add("craftedAt", "piece_magetable");
			new JotunnItemFactory.JotunnItem(dictionary, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(92f, 0f, 300f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(24f, 0f, 200f, item4: true)
				},
				{
					"spirit_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(5f, 0f, 60f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(20f, 0f, 300f, item4: true)
				},
				{
					"draw_stamina_drain",
					new Tuple<float, float, float, bool>(6f, 1f, 50f, item4: true)
				},
				{
					"primary_attack_flat_health_cost",
					new Tuple<float, float, float, bool>(12f, 0f, 25f, item4: true)
				},
				{
					"primary_attack_percent_health_cost",
					new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 500f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"bow_draw_speed",
					new Tuple<float, float, float, bool>(2f, 0.01f, 2f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(60f, 0f, 120f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"YggdrasilWood",
					new Tuple<int, int>(14, 7)
				},
				{
					"Iron",
					new Tuple<int, int>(10, 6)
				},
				{
					"Carapace",
					new Tuple<int, int>(24, 10)
				},
				{
					"TrophyTick",
					new Tuple<int, int>(2, 0)
				},
				{
					"Eitr",
					new Tuple<int, int>(0, 10)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			dictionary2.Add("name", "Blood Bone Bow");
			dictionary2.Add("catagory", "Bows");
			dictionary2.Add("prefab", "VABlood_bone_bow");
			dictionary2.Add("sprite", "bone_bow");
			dictionary2.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary2, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(60f, 0f, 300f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(18f, 0f, 200f, item4: true)
				},
				{
					"spirit_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(20f, 0f, 300f, item4: true)
				},
				{
					"draw_stamina_drain",
					new Tuple<float, float, float, bool>(4f, 1f, 50f, item4: true)
				},
				{
					"primary_attack_flat_health_cost",
					new Tuple<float, float, float, bool>(8f, 0f, 25f, item4: true)
				},
				{
					"primary_attack_percent_health_cost",
					new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 500f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"bow_draw_speed",
					new Tuple<float, float, float, bool>(2f, 0.01f, 2f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(60f, 0f, 120f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"ElderBark",
					new Tuple<int, int>(10, 5)
				},
				{
					"Silver",
					new Tuple<int, int>(10, 5)
				},
				{
					"BoneFragments",
					new Tuple<int, int>(20, 10)
				},
				{
					"TrophyUlv",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
			dictionary3.Add("name", "Bronze Arbelist");
			dictionary3.Add("catagory", "Bows");
			dictionary3.Add("prefab", "VAArbalistBronze");
			dictionary3.Add("sprite", "bronze_crossbow_upright");
			dictionary3.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary3, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(105f, 0f, 300f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"crossbow_reload_speed",
					new Tuple<float, float, float, bool>(3.5f, 0.01f, 3.5f, item4: true)
				},
				{
					"crossbow_reload_stamina_drain",
					new Tuple<float, float, float, bool>(1f, 1f, 50f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"ElderBark",
					new Tuple<int, int>(10, 5)
				},
				{
					"Bronze",
					new Tuple<int, int>(20, 10)
				},
				{
					"Tar",
					new Tuple<int, int>(10, 2)
				},
				{
					"LinenThread",
					new Tuple<int, int>(2, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
			dictionary4.Add("name", "Eikthyrs Bow");
			dictionary4.Add("catagory", "Bows");
			dictionary4.Add("prefab", "VAAntler_Bow");
			dictionary4.Add("sprite", "antler_bow");
			dictionary4.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary4, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(26f, 0f, 120f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(4f, 0f, 90f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(5f, 0f, 50f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"draw_stamina_drain",
					new Tuple<float, float, float, bool>(6f, 1f, 50f, item4: true)
				},
				{
					"bow_draw_speed",
					new Tuple<float, float, float, bool>(2.5f, 0.01f, 2.5f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(45f, 0f, 120f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(15, 5)
				},
				{
					"Resin",
					new Tuple<int, int>(20, 10)
				},
				{
					"HardAntler",
					new Tuple<int, int>(3, 3)
				},
				{
					"TrophyEikthyr",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary5 = new Dictionary<string, string>();
			dictionary5.Add("name", "Bronze Crossbow");
			dictionary5.Add("catagory", "Bows");
			dictionary5.Add("prefab", "VACrossbowBronze");
			dictionary5.Add("sprite", "bronze_crossbow2");
			dictionary5.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary5, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(80f, 0f, 300f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(150f, 0f, 300f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"crossbow_reload_speed",
					new Tuple<float, float, float, bool>(3.5f, 0.01f, 3.5f, item4: true)
				},
				{
					"crossbow_reload_stamina_drain",
					new Tuple<float, float, float, bool>(1f, 1f, 50f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(10, 5)
				},
				{
					"RoundLog",
					new Tuple<int, int>(10, 5)
				},
				{
					"Bronze",
					new Tuple<int, int>(4, 0)
				},
				{
					"DeerHide",
					new Tuple<int, int>(2, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary6 = new Dictionary<string, string>();
			dictionary6.Add("name", "Elders Reach");
			dictionary6.Add("catagory", "Bows");
			dictionary6.Add("prefab", "VACrossbowElder");
			dictionary6.Add("sprite", "elder_crossbow");
			dictionary6.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary6, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(80f, 0f, 300f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(20f, 0f, 300f, item4: true)
				},
				{
					"spirit_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(150f, 0f, 300f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"crossbow_reload_speed",
					new Tuple<float, float, float, bool>(3.5f, 0.01f, 3.5f, item4: true)
				},
				{
					"crossbow_reload_stamina_drain",
					new Tuple<float, float, float, bool>(1f, 1f, 50f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Bronze",
					new Tuple<int, int>(4, 2)
				},
				{
					"RoundLog",
					new Tuple<int, int>(20, 10)
				},
				{
					"CryptKey",
					new Tuple<int, int>(1, 0)
				},
				{
					"TrophyTheElder",
					new Tuple<int, int>(1, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary7 = new Dictionary<string, string>();
			dictionary7.Add("name", "Moder Crossbow");
			dictionary7.Add("catagory", "Bows");
			dictionary7.Add("prefab", "VACrossbowModer");
			dictionary7.Add("sprite", "moder_crossbow");
			dictionary7.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary7, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(150f, 0f, 300f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"frost",
					new Tuple<float, float, float, bool>(25f, 0f, 300f, item4: true)
				},
				{
					"frost_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"crossbow_reload_speed",
					new Tuple<float, float, float, bool>(3.5f, 0.01f, 3.5f, item4: true)
				},
				{
					"crossbow_reload_stamina_drain",
					new Tuple<float, float, float, bool>(1f, 1f, 50f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"ElderBark",
					new Tuple<int, int>(10, 5)
				},
				{
					"Obsidian",
					new Tuple<int, int>(20, 10)
				},
				{
					"DragonTear",
					new Tuple<int, int>(10, 0)
				},
				{
					"TrophyDragonQueen",
					new Tuple<int, int>(1, 0)
				},
				{
					"Silver",
					new Tuple<int, int>(0, 6)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary8 = new Dictionary<string, string>();
			dictionary8.Add("name", "Queens Greatbow");
			dictionary8.Add("catagory", "Bows");
			dictionary8.Add("prefab", "VAQueen_bow");
			dictionary8.Add("sprite", "queen_bow");
			dictionary8.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary8, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(72f, 0f, 200f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"poison",
					new Tuple<float, float, float, bool>(25f, 0f, 90f, item4: true)
				},
				{
					"poison_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(30f, 0f, 99f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(25f, 0f, 50f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"draw_stamina_drain",
					new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
				},
				{
					"bow_draw_speed",
					new Tuple<float, float, float, bool>(3f, 0.01f, 3f, item4: true)
				},
				{
					"projectile_velocity",
					new Tuple<float, float, float, bool>(60f, 0f, 120f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"YggdrasilWood",
					new Tuple<int, int>(10, 5)
				},
				{
					"Eitr",
					new Tuple<int, int>(20, 10)
				},
				{
					"JuteBlue",
					new Tuple<int, int>(4, 0)
				},
				{
					"TrophySeekerQueen",
					new Tuple<int, int>(1, 0)
				},
				{
					"Carapace",
					new Tuple<int, int>(0, 4)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
		}

		private void LoadSwords()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("name", "Blackmetal Greatsword");
			dictionary.Add("catagory", "Swords");
			dictionary.Add("prefab", "VABlackmetal_greatsword");
			dictionary.Add("sprite", "blackmetal_greatsword");
			dictionary.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(125f, 0f, 250f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(52f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(18f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(36f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"BlackMetal",
					new Tuple<int, int>(30, 10)
				},
				{
					"LinenThread",
					new Tuple<int, int>(10, 5)
				},
				{
					"FineWood",
					new Tuple<int, int>(6, 3)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			dictionary2.Add("name", "Abyssal Sword");
			dictionary2.Add("catagory", "Swords");
			dictionary2.Add("prefab", "VASwordChitin");
			dictionary2.Add("sprite", "chitin_sword");
			dictionary2.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary2, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(20f, 0f, 90f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(4f, 0f, 25f, item4: true)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(25f, 0f, 120f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(18f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(10f, 1f, 30f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(2, 1)
				},
				{
					"Chitin",
					new Tuple<int, int>(30, 15)
				},
				{
					"DeerHide",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
			dictionary3.Add("name", "Eikthyrs Sword");
			dictionary3.Add("catagory", "Swords");
			dictionary3.Add("prefab", "VAAntler_Sword");
			dictionary3.Add("sprite", "antler_sword");
			dictionary3.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary3, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(16f, 0f, 90f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(8f, 0f, 90f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(6f, 0f, 120f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(8f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(8f, 1f, 30f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(3, 1)
				},
				{
					"Resin",
					new Tuple<int, int>(16, 8)
				},
				{
					"HardAntler",
					new Tuple<int, int>(3, 3)
				},
				{
					"TrophyEikthyr",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
			dictionary4.Add("name", "Elders Balance");
			dictionary4.Add("catagory", "Swords");
			dictionary4.Add("prefab", "VAVine_Sword");
			dictionary4.Add("sprite", "vine_sword");
			dictionary4.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary4, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(35f, 0f, 90f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
				},
				{
					"spirit_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(12f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(8f, 1f, 30f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Bronze",
					new Tuple<int, int>(2, 1)
				},
				{
					"Stone",
					new Tuple<int, int>(16, 8)
				},
				{
					"CryptKey",
					new Tuple<int, int>(1, 0)
				},
				{
					"TrophyTheElder",
					new Tuple<int, int>(1, 0)
				},
				{
					"RoundLog",
					new Tuple<int, int>(0, 4)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary5 = new Dictionary<string, string>();
			dictionary5.Add("name", "Moders Grasp");
			dictionary5.Add("catagory", "Swords");
			dictionary5.Add("prefab", "VASwordModer");
			dictionary5.Add("sprite", "moder_sword");
			dictionary5.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary5, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(35f, 0f, 90f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(30f, 0f, 90f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
				},
				{
					"frost",
					new Tuple<float, float, float, bool>(25f, 0f, 120f, item4: true)
				},
				{
					"frost_per_level",
					new Tuple<float, float, float, bool>(1f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(30f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(12f, 1f, 30f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"ElderBark",
					new Tuple<int, int>(4, 2)
				},
				{
					"Obsidian",
					new Tuple<int, int>(30, 15)
				},
				{
					"DragonTear",
					new Tuple<int, int>(10, 0)
				},
				{
					"TrophyDragonQueen",
					new Tuple<int, int>(1, 0)
				},
				{
					"Silver",
					new Tuple<int, int>(0, 2)
				},
				{
					"JuteRed",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary6 = new Dictionary<string, string>();
			dictionary6.Add("name", "Moders Greatsword");
			dictionary6.Add("catagory", "Swords");
			dictionary6.Add("prefab", "VAModer_greatsword");
			dictionary6.Add("sprite", "moder_greatsword");
			dictionary6.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary6, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(55f, 0f, 90f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(40f, 0f, 90f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
				},
				{
					"frost",
					new Tuple<float, float, float, bool>(25f, 0f, 120f, item4: true)
				},
				{
					"frost_per_level",
					new Tuple<float, float, float, bool>(1f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(48f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(17f, 1f, 30f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(34f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Crystal",
					new Tuple<int, int>(25, 10)
				},
				{
					"Obsidian",
					new Tuple<int, int>(15, 10)
				},
				{
					"DragonTear",
					new Tuple<int, int>(10, 0)
				},
				{
					"TrophyDragonQueen",
					new Tuple<int, int>(1, 0)
				},
				{
					"Silver",
					new Tuple<int, int>(0, 4)
				},
				{
					"JuteRed",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary7 = new Dictionary<string, string>();
			dictionary7.Add("name", "Bronze Greatsword");
			dictionary7.Add("catagory", "Swords");
			dictionary7.Add("prefab", "VAbronze_greatsword");
			dictionary7.Add("sprite", "bronze_greatsword_reforged");
			dictionary7.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary7, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(50f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(16f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"RoundLog",
					new Tuple<int, int>(4, 0)
				},
				{
					"Bronze",
					new Tuple<int, int>(20, 10)
				},
				{
					"DeerHide",
					new Tuple<int, int>(3, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary8 = new Dictionary<string, string>();
			dictionary8.Add("name", "Iron Greatsword");
			dictionary8.Add("catagory", "Swords");
			dictionary8.Add("prefab", "VAiron_greatsword");
			dictionary8.Add("sprite", "iron_greatsword_reforged");
			dictionary8.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary8, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(75f, 0f, 250f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(28f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(28f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"ElderBark",
					new Tuple<int, int>(15, 5)
				},
				{
					"Iron",
					new Tuple<int, int>(30, 15)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(4, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary9 = new Dictionary<string, string>();
			dictionary9.Add("name", "Silver Greatsword");
			dictionary9.Add("catagory", "Swords");
			dictionary9.Add("prefab", "VAsilver_greatsword");
			dictionary9.Add("sprite", "silver_greatsword_reforged");
			dictionary9.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary9, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
				},
				{
					"spirit_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(40f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(32f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(10, 5)
				},
				{
					"Silver",
					new Tuple<int, int>(25, 10)
				},
				{
					"Iron",
					new Tuple<int, int>(4, 2)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(3, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary10 = new Dictionary<string, string>();
			dictionary10.Add("name", "Bonemasses Greatsword");
			dictionary10.Add("catagory", "Swords");
			dictionary10.Add("prefab", "VABonemassGreatsword");
			dictionary10.Add("sprite", "bonemass_greatsword");
			dictionary10.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary10, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(75f, 0f, 250f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"poison",
					new Tuple<float, float, float, bool>(20f, 0f, 250f, item4: true)
				},
				{
					"poison_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(36f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(15f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"WitheredBone",
					new Tuple<int, int>(15, 5)
				},
				{
					"Iron",
					new Tuple<int, int>(30, 15)
				},
				{
					"Wishbone",
					new Tuple<int, int>(1, 0)
				},
				{
					"TrophyBonemass",
					new Tuple<int, int>(1, 0)
				},
				{
					"ElderBark",
					new Tuple<int, int>(0, 2)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
			Dictionary<string, string> dictionary11 = new Dictionary<string, string>();
			dictionary11.Add("name", "Yagluths Greatsword");
			dictionary11.Add("catagory", "Swords");
			dictionary11.Add("prefab", "VAYagluth_greatsword");
			dictionary11.Add("sprite", "yagluth_greatsword");
			dictionary11.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary11, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(125f, 0f, 250f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"fire",
					new Tuple<float, float, float, bool>(25f, 0f, 250f, item4: true)
				},
				{
					"fire_per_level",
					new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(49f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(18f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(36f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"BlackMetal",
					new Tuple<int, int>(10, 5)
				},
				{
					"Iron",
					new Tuple<int, int>(4, 2)
				},
				{
					"YagluthDrop",
					new Tuple<int, int>(2, 0)
				},
				{
					"TrophyGoblinKing",
					new Tuple<int, int>(1, 0)
				},
				{
					"Tar",
					new Tuple<int, int>(0, 3)
				},
				{
					"LinenThread",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary12 = new Dictionary<string, string>();
			dictionary12.Add("name", "Flint Sword");
			dictionary12.Add("catagory", "Swords");
			dictionary12.Add("prefab", "VAFlint_Sword");
			dictionary12.Add("sprite", "flint_sword");
			dictionary12.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary12, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(15f, 0f, 90f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(4f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(6f, 1f, 30f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(2, 0)
				},
				{
					"Flint",
					new Tuple<int, int>(6, 3)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary13 = new Dictionary<string, string>();
			dictionary13.Add("name", "Flint Greatsword");
			dictionary13.Add("catagory", "Swords");
			dictionary13.Add("prefab", "VAFlint_greatsword");
			dictionary13.Add("sprite", "flint_greatsword");
			dictionary13.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary13, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(25f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(14f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(10f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(4, 0)
				},
				{
					"Flint",
					new Tuple<int, int>(9, 5)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary14 = new Dictionary<string, string>();
			dictionary14.Add("name", "Queen Greatsword");
			dictionary14.Add("catagory", "Swords");
			dictionary14.Add("prefab", "VAQueen_greatsword");
			dictionary14.Add("sprite", "queen_greatsword");
			dictionary14.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary14, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(125f, 0f, 250f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"poison",
					new Tuple<float, float, float, bool>(25f, 0f, 250f, item4: true)
				},
				{
					"poison_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(30f, 0f, 99f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(62f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(40f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"YggdrasilWood",
					new Tuple<int, int>(10, 5)
				},
				{
					"Eitr",
					new Tuple<int, int>(20, 10)
				},
				{
					"JuteBlue",
					new Tuple<int, int>(4, 2)
				},
				{
					"TrophySeekerQueen",
					new Tuple<int, int>(1, 0)
				},
				{
					"Carapace",
					new Tuple<int, int>(0, 8)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary15 = new Dictionary<string, string>();
			dictionary15.Add("name", "Queen Sword");
			dictionary15.Add("catagory", "Swords");
			dictionary15.Add("prefab", "VASwordQueen");
			dictionary15.Add("sprite", "queen_sword");
			dictionary15.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary15, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(95f, 0f, 250f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"poison",
					new Tuple<float, float, float, bool>(25f, 0f, 250f, item4: true)
				},
				{
					"poison_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(30f, 0f, 99f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(40f, 0f, 160f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(52f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(32f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"YggdrasilWood",
					new Tuple<int, int>(3, 1)
				},
				{
					"Eitr",
					new Tuple<int, int>(10, 5)
				},
				{
					"JuteBlue",
					new Tuple<int, int>(3, 1)
				},
				{
					"TrophySeekerQueen",
					new Tuple<int, int>(1, 0)
				},
				{
					"Carapace",
					new Tuple<int, int>(0, 6)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
		}

		private void LoadAxes()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("name", "Flint greataxe");
			dictionary.Add("catagory", "Axes");
			dictionary.Add("prefab", "VAFlint_greataxe");
			dictionary.Add("sprite", "flint_greataxe");
			dictionary.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(25f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"chop",
					new Tuple<float, float, float, bool>(45f, 0f, 200f, item4: true)
				},
				{
					"chop_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(14f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 20f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(8, 0)
				},
				{
					"Flint",
					new Tuple<int, int>(9, 5)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			dictionary2.Add("name", "Flint dualaxes");
			dictionary2.Add("catagory", "Axes");
			dictionary2.Add("prefab", "VAFlint_dualaxes");
			dictionary2.Add("sprite", "flint_dualaxes");
			dictionary2.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary2, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(20f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"chop",
					new Tuple<float, float, float, bool>(30f, 0f, 200f, item4: true)
				},
				{
					"chop_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(12f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(175f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(6f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(14f, 1f, 20f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(10, 6)
				},
				{
					"Flint",
					new Tuple<int, int>(9, 5)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(2, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
			dictionary3.Add("name", "Bronze Lumber Axe");
			dictionary3.Add("catagory", "Axes");
			dictionary3.Add("prefab", "VAbronze_battleaxe");
			dictionary3.Add("sprite", "bronze_axe_rebuild");
			dictionary3.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary3, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(50f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"chop",
					new Tuple<float, float, float, bool>(30f, 0f, 200f, item4: true)
				},
				{
					"chop_per_level",
					new Tuple<float, float, float, bool>(2.5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(18f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(28f, 1f, 20f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"RoundLog",
					new Tuple<int, int>(20, 5)
				},
				{
					"Bronze",
					new Tuple<int, int>(10, 5)
				},
				{
					"DeerHide",
					new Tuple<int, int>(2, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
			dictionary4.Add("name", "Bronze dualaxes");
			dictionary4.Add("catagory", "Axes");
			dictionary4.Add("prefab", "VABronze_dualaxes");
			dictionary4.Add("sprite", "bronze_dualaxes");
			dictionary4.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary4, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(45f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"chop",
					new Tuple<float, float, float, bool>(35f, 0f, 200f, item4: true)
				},
				{
					"chop_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(12f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(175f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(8f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(16f, 1f, 20f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"RoundLog",
					new Tuple<int, int>(10, 4)
				},
				{
					"Bronze",
					new Tuple<int, int>(20, 8)
				},
				{
					"DeerHide",
					new Tuple<int, int>(2, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary5 = new Dictionary<string, string>();
			dictionary5.Add("name", "Iron dualaxes");
			dictionary5.Add("catagory", "Axes");
			dictionary5.Add("prefab", "VAIron_dualaxes");
			dictionary5.Add("sprite", "iron_dualaxes");
			dictionary5.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary5, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(65f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"chop",
					new Tuple<float, float, float, bool>(55f, 0f, 200f, item4: true)
				},
				{
					"chop_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(12f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(175f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(9f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(18f, 1f, 20f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"ElderBark",
					new Tuple<int, int>(25, 8)
				},
				{
					"Iron",
					new Tuple<int, int>(30, 15)
				},
				{
					"DeerHide",
					new Tuple<int, int>(6, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary6 = new Dictionary<string, string>();
			dictionary6.Add("name", "Eikthyrs Greataxe");
			dictionary6.Add("catagory", "Axes");
			dictionary6.Add("prefab", "VAAntler_greataxe");
			dictionary6.Add("sprite", "antler_greataxe");
			dictionary6.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary6, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(10f, 0f, 200f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(25f, 0f, 200f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(10f, 0f, 200f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
				},
				{
					"chop",
					new Tuple<float, float, float, bool>(30f, 0f, 200f, item4: true)
				},
				{
					"chop_per_level",
					new Tuple<float, float, float, bool>(2.5f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(18f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(28f, 1f, 20f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(15, 0)
				},
				{
					"Resin",
					new Tuple<int, int>(30, 15)
				},
				{
					"HardAntler",
					new Tuple<int, int>(3, 3)
				},
				{
					"TrophyEikthyr",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary7 = new Dictionary<string, string>();
			dictionary7.Add("name", "Blackmetal Battleaxe");
			dictionary7.Add("catagory", "Axes");
			dictionary7.Add("prefab", "VAblackmetal_battleaxe");
			dictionary7.Add("sprite", "blackmetal_battleaxe");
			dictionary7.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary7, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"slash",
					new Tuple<float, float, float, bool>(120f, 0f, 300f, item4: true)
				},
				{
					"slash_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"chop",
					new Tuple<float, float, float, bool>(60f, 0f, 300f, item4: true)
				},
				{
					"chop_per_level",
					new Tuple<float, float, float, bool>(2.5f, 0f, 25f, item4: true)
				},
				{
					"fire",
					new Tuple<float, float, float, bool>(20f, 0f, 160f, item4: true)
				},
				{
					"fire_per_level",
					new Tuple<float, float, float, bool>(0f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(52f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(40f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(10, 5)
				},
				{
					"BlackMetal",
					new Tuple<int, int>(35, 15)
				},
				{
					"LinenThread",
					new Tuple<int, int>(5, 0)
				},
				{
					"SurtlingCore",
					new Tuple<int, int>(4, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
		}

		private void LoadHammers()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("name", "Flametal nature sledge");
			dictionary.Add("catagory", "Hammers");
			dictionary.Add("prefab", "VAflametal_sledge_nature");
			dictionary.Add("sprite", "flametal_sledge_nature");
			dictionary.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(165f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"poison",
					new Tuple<float, float, float, bool>(25f, 0f, 300f, item4: true)
				},
				{
					"poison_per_level",
					new Tuple<float, float, float, bool>(3f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(56f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"VAflametal_sledge",
					new Tuple<int, int>(1, 0)
				},
				{
					"FlametalNew",
					new Tuple<int, int>(8, 8)
				},
				{
					"Blackwood",
					new Tuple<int, int>(5, 0)
				},
				{
					"GemstoneGreen",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			dictionary2.Add("name", "Flametal lightning sledge");
			dictionary2.Add("catagory", "Hammers");
			dictionary2.Add("prefab", "VAflametal_sledge_lightning");
			dictionary2.Add("sprite", "flametal_sledge_lightning");
			dictionary2.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary2, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(165f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(20f, 0f, 300f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(56f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"VAflametal_sledge",
					new Tuple<int, int>(1, 0)
				},
				{
					"FlametalNew",
					new Tuple<int, int>(8, 8)
				},
				{
					"Blackwood",
					new Tuple<int, int>(5, 0)
				},
				{
					"GemstoneBlue",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
			dictionary3.Add("name", "Flametal blood sledge");
			dictionary3.Add("catagory", "Hammers");
			dictionary3.Add("prefab", "VAflametal_sledge_blood");
			dictionary3.Add("sprite", "flametal_sledge_blood");
			dictionary3.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary3, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(175f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(10f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(56f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"VAflametal_sledge",
					new Tuple<int, int>(1, 0)
				},
				{
					"FlametalNew",
					new Tuple<int, int>(8, 8)
				},
				{
					"Blackwood",
					new Tuple<int, int>(5, 0)
				},
				{
					"GemstoneRed",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
			dictionary4.Add("name", "Flametal sledge");
			dictionary4.Add("catagory", "Hammers");
			dictionary4.Add("prefab", "VAflametal_sledge");
			dictionary4.Add("sprite", "flametal_sledge");
			dictionary4.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary4, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(165f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(56f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FlametalNew",
					new Tuple<int, int>(30, 15)
				},
				{
					"Iron",
					new Tuple<int, int>(4, 0)
				},
				{
					"Eitr",
					new Tuple<int, int>(6, 3)
				},
				{
					"Blackwood",
					new Tuple<int, int>(12, 6)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary5 = new Dictionary<string, string>();
			dictionary5.Add("name", "Blackmarble mace");
			dictionary5.Add("catagory", "Hammers");
			dictionary5.Add("prefab", "VAmistland_mace");
			dictionary5.Add("sprite", "mist_mace");
			dictionary5.Add("craftedAt", "blackforge");
			new JotunnItemFactory.JotunnItem(dictionary5, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(115f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(48f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(15f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(28f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.05f, -0.05f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"YggdrasilWood",
					new Tuple<int, int>(6, 4)
				},
				{
					"Bronze",
					new Tuple<int, int>(10, 5)
				},
				{
					"Eitr",
					new Tuple<int, int>(8, 2)
				},
				{
					"BlackMarble",
					new Tuple<int, int>(20, 10)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary6 = new Dictionary<string, string>();
			dictionary6.Add("name", "Blackmetal Sledge");
			dictionary6.Add("catagory", "Hammers");
			dictionary6.Add("prefab", "VAblackmetal_sledge");
			dictionary6.Add("sprite", "blackmetal_hammer");
			dictionary6.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary6, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(120f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(0f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(49f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(40f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(10, 5)
				},
				{
					"BlackMetal",
					new Tuple<int, int>(30, 10)
				},
				{
					"LinenThread",
					new Tuple<int, int>(5, 0)
				},
				{
					"Thunderstone",
					new Tuple<int, int>(4, 0)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 4 } });
			Dictionary<string, string> dictionary7 = new Dictionary<string, string>();
			dictionary7.Add("name", "Elders Rock");
			dictionary7.Add("catagory", "Hammers");
			dictionary7.Add("prefab", "VAElderHammer");
			dictionary7.Add("sprite", "elder_hammer");
			dictionary7.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary7, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(50f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(20f, 0f, 99f, item4: true)
				},
				{
					"spirit_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(22f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(22f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Bronze",
					new Tuple<int, int>(4, 2)
				},
				{
					"Stone",
					new Tuple<int, int>(30, 15)
				},
				{
					"CryptKey",
					new Tuple<int, int>(1, 0)
				},
				{
					"TrophyTheElder",
					new Tuple<int, int>(1, 0)
				},
				{
					"RoundLog",
					new Tuple<int, int>(0, 8)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary8 = new Dictionary<string, string>();
			dictionary8.Add("name", "Bronze Sledge");
			dictionary8.Add("catagory", "Hammers");
			dictionary8.Add("prefab", "VABronzeSledge");
			dictionary8.Add("sprite", "bronze_sledge");
			dictionary8.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary8, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(35f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(22f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(22f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Bronze",
					new Tuple<int, int>(8, 4)
				},
				{
					"Stone",
					new Tuple<int, int>(25, 15)
				},
				{
					"TrollHide",
					new Tuple<int, int>(6, 3)
				},
				{
					"RoundLog",
					new Tuple<int, int>(4, 4)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary9 = new Dictionary<string, string>();
			dictionary9.Add("name", "Bonemasses Rage");
			dictionary9.Add("catagory", "Hammers");
			dictionary9.Add("prefab", "VABonemassWarhammer");
			dictionary9.Add("sprite", "bonemass_warhammer");
			dictionary9.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary9, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(70f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"poison",
					new Tuple<float, float, float, bool>(20f, 0f, 99f, item4: true)
				},
				{
					"poison_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(31f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"WitheredBone",
					new Tuple<int, int>(10, 5)
				},
				{
					"Iron",
					new Tuple<int, int>(30, 10)
				},
				{
					"Wishbone",
					new Tuple<int, int>(1, 0)
				},
				{
					"TrophyBonemass",
					new Tuple<int, int>(1, 0)
				},
				{
					"ElderBark",
					new Tuple<int, int>(0, 2)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
			Dictionary<string, string> dictionary10 = new Dictionary<string, string>();
			dictionary10.Add("name", "Silver Sledge");
			dictionary10.Add("catagory", "Hammers");
			dictionary10.Add("prefab", "VASilverSledge");
			dictionary10.Add("sprite", "silver_sledge");
			dictionary10.Add("craftedAt", "forge");
			new JotunnItemFactory.JotunnItem(dictionary10, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(85f, 0f, 300f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
				},
				{
					"spirit",
					new Tuple<float, float, float, bool>(25f, 0f, 99f, item4: true)
				},
				{
					"spirit_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(31f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(200f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(15f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				},
				{
					"movement_speed",
					new Tuple<float, float, float, bool>(-0.2f, -0.2f, 0f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"RoundLog",
					new Tuple<int, int>(10, 5)
				},
				{
					"Silver",
					new Tuple<int, int>(30, 15)
				},
				{
					"YmirRemains",
					new Tuple<int, int>(4, 2)
				},
				{
					"TrophyFenring",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		}

		private void LoadAtgeirs()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("name", "Flint Atgeir");
			dictionary.Add("catagory", "Atgeirs");
			dictionary.Add("prefab", "VAAtgeir_Flint");
			dictionary.Add("sprite", "flint_atgeir");
			dictionary.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(25f, 0f, 90f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(11f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(125f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(10f, 1f, 20f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"Wood",
					new Tuple<int, int>(10, 0)
				},
				{
					"Flint",
					new Tuple<int, int>(6, 3)
				},
				{
					"LeatherScraps",
					new Tuple<int, int>(0, 2)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			dictionary2.Add("name", "Eikthyrs Atgeir");
			dictionary2.Add("catagory", "Atgeirs");
			dictionary2.Add("prefab", "VAatgeir_antler");
			dictionary2.Add("sprite", "antler_atgeir");
			dictionary2.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary2, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(35f, 0f, 90f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
				},
				{
					"lightning",
					new Tuple<float, float, float, bool>(10f, 0f, 25f, item4: true)
				},
				{
					"lightning_per_level",
					new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(14f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(175f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(12f, 1f, 20f, item4: true)
				},
				{
					"secondary_attack_stamina",
					new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
				}
			}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
			{
				{
					"FineWood",
					new Tuple<int, int>(15, 0)
				},
				{
					"Resin",
					new Tuple<int, int>(30, 15)
				},
				{
					"HardAntler",
					new Tuple<int, int>(3, 3)
				},
				{
					"TrophyEikthyr",
					new Tuple<int, int>(1, 1)
				}
			}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
			dictionary3.Add("name", "Abyssal Atgeir");
			dictionary3.Add("catagory", "Atgeirs");
			dictionary3.Add("prefab", "VAAtgeirchitin");
			dictionary3.Add("sprite", "chitin_heavy_atgeir_small2");
			dictionary3.Add("craftedAt", "piece_workbench");
			new JotunnItemFactory.JotunnItem(dictionary3, new Dictionary<string, Tuple<float, float, float, bool>>
			{
				{
					"amount",
					new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
				},
				{
					"pierce",
					new Tuple<float, float, float, bool>(35f, 0f, 140f, item4: true)
				},
				{
					"pierce_per_level",
					new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
				},
				{
					"blunt",
					new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
				},
				{
					"blunt_per_level",
					new Tuple<float, float, float, bool>(4f, 0f, 25f, item4: true)
				},
				{
					"attack_force",
					new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
				},
				{
					"block",
					new Tuple<float, float, float, bool>(21f, 0f, 60f, item4: true)
				},
				{
					"durability",
					new Tuple<float, float, float, bool>(175f, 0f, 400f, item4: true)
				},
				{
					"durability_per_level",
					new Tuple<float, float, float, bool>(50f, 0f, 75f, item4: true)
				},
				{
					"primary_attack_stamina",
					new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
				},
				{
					"secondary_attack_stamina