using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Common;
using Digitalroot.Valheim.Bounties.CMB;
using Digitalroot.Valheim.Bounties.Extensions;
using Digitalroot.Valheim.Bounties.Providers;
using Digitalroot.Valheim.Common;
using Digitalroot.Valheim.Common.Json;
using Digitalroot.Valheim.Common.Names.BearsMod;
using Digitalroot.Valheim.Common.Names.FriendliesMod;
using Digitalroot.Valheim.Common.Names.MonsterLabZMod;
using Digitalroot.Valheim.Common.Names.MonsternomiconMod;
using Digitalroot.Valheim.Common.Names.RRRMod;
using Digitalroot.Valheim.Common.Names.SupplementalRaidsMod;
using Digitalroot.Valheim.Common.Names.Vanilla;
using EpicLoot;
using EpicLoot.Adventure;
using EpicLoot.Adventure.Feature;
using EpicLoot.Patching;
using HarmonyLib;
using JetBrains.Annotations;
using SimpleJson;
using UnityEngine;

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

		[UsedImplicitly]
		public static ConfigEntry<int> NexusId;

		public static Main Instance;

		private int _bountiesCount;

		private readonly List<AbstractBounties> _bountiesList = new List<AbstractBounties>();

		private readonly string _patchPath;

		public const string MonsterLabZ = "MonsterLabZ";

		public const string Bears = "som.Bears";

		public const string SpawnThat = "asharppen.valheim.spawn_that";

		public const string RRRCore = "com.alexanderstrada.rrrcore";

		public const string RRRNpcs = "com.alexanderstrada.rrrnpcs";

		public const string RRRMonsters = "com.alexanderstrada.rrrmonsters";

		private bool _isBearsBountiesEnabled = true;

		private bool _isFriendliesBountiesEnabled = true;

		private bool _isMonsterLabZBountiesEnabled = true;

		private bool _isMonsternomiconBountiesEnabled = true;

		private bool _isRRRMonsterBountiesEnabled = true;

		private bool _isSupplementalRaidsBountiesEnabled = true;

		private bool _isVanillaBountiesEnabled = true;

		public const string Version = "3.0.21";

		public const string Name = "Digitalroot's Bounties";

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

		public const string Namespace = "Digitalroot.ValheimBounties";

		private static List<BountyTargetConfig> Bounties => AdventureDataManager.Config.Bounties.Targets;

		public SoftDependencies SoftDependencies { get; private set; }

		public string Source => "Digitalroot.ValheimBounties";

		public bool EnableTrace { get; }

		public Main()
		{
			Instance = this;
			EnableTrace = false;
			Log.RegisterSource(Instance);
			Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
			_patchPath = Path.Combine(Paths.ConfigPath, "EpicLoot", "patches", "Digitalroot", "Bounties");
		}

		[UsedImplicitly]
		private void Awake()
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				NexusId = ((BaseUnityPlugin)this).Config.Bind<int>("General", "NexusID", 1401, "Nexus mod ID for updates");
				SoftDependencies = new SoftDependencies();
				_harmony = Harmony.CreateAndPatchAll(typeof(Main).Assembly, "digitalroot.mods.bounties");
				Log.Trace(Instance, "_patchPath: " + _patchPath);
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

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

		public void AddToBountiesCollection(AbstractBounties bounties)
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				if (!_bountiesList.Any((AbstractBounties bountiesItem) => bountiesItem.GetType().Name == bounties.GetType().Name))
				{
					_bountiesList.Add(bounties);
				}
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		public void ConfigureBounties()
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				lock (Instance)
				{
					Log.Trace(Instance, "********** [Bounties Enabled] **********");
					Log.Trace(Instance, $"_isBearsBountiesEnabled : {_isBearsBountiesEnabled}");
					Log.Trace(Instance, $"_isFriendliesBountiesEnabled : {_isFriendliesBountiesEnabled}");
					Log.Trace(Instance, $"_isMonsterLabZBountiesEnabled : {_isMonsterLabZBountiesEnabled}");
					Log.Trace(Instance, $"_isMonsternomiconBountiesEnabled : {_isMonsternomiconBountiesEnabled}");
					Log.Trace(Instance, $"_isRRRMonsterBountiesEnabled : {_isRRRMonsterBountiesEnabled}");
					Log.Trace(Instance, $"_isSupplementalRaidsBountiesEnabled : {_isSupplementalRaidsBountiesEnabled}");
					Log.Trace(Instance, $"_isVanillaBountiesEnabled : {_isVanillaBountiesEnabled}");
					Log.Debug(Instance, SoftDependencies.ToString());
					Log.Trace(Instance, "********** [Bounties Enabled] **********");
					Log.Trace(Instance, $"[{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}] _bountiesList.Count : {_bountiesList.Count}");
					if (_isBearsBountiesEnabled)
					{
						AddToBountiesCollection(new BearsBounties());
					}
					if (_isMonsterLabZBountiesEnabled)
					{
						AddToBountiesCollection(new MonsterLabZBounties());
					}
					if (_isMonsternomiconBountiesEnabled)
					{
						AddToBountiesCollection(new MonsternomiconBounties());
					}
					if (_isRRRMonsterBountiesEnabled)
					{
						AddToBountiesCollection(new RRRMonsterBounties());
					}
					if (_isSupplementalRaidsBountiesEnabled)
					{
						AddToBountiesCollection(new SupplementalRaidsBounties());
					}
					if (_isVanillaBountiesEnabled)
					{
						AddToBountiesCollection(new VanillaBounties());
					}
					CreateBountiesPatchs();
				}
			}
			catch (Exception ex)
			{
				Log.Error(Instance, ex.Message);
				Log.Error(Instance, ex);
			}
		}

		public void OnPatchZNetSceneAwake(ref ZNetScene zNetScene)
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				ConfigureBounties();
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		public void DisableBearsBounties()
		{
			_isBearsBountiesEnabled = false;
		}

		public void DisableFriendliesBounties()
		{
			_isFriendliesBountiesEnabled = false;
		}

		public void DisableMonsterLabZBounties()
		{
			_isMonsterLabZBountiesEnabled = false;
		}

		public void DisableMonsternomiconBounties()
		{
			_isMonsternomiconBountiesEnabled = false;
		}

		public void DisableRRRMonsterBounties()
		{
			_isRRRMonsterBountiesEnabled = false;
		}

		public void DisableSupplementalRaidsBounties()
		{
			_isSupplementalRaidsBountiesEnabled = false;
		}

		public void DisableVanillaBounties()
		{
			_isVanillaBountiesEnabled = false;
		}

		[UsedImplicitly]
		public void DisabledAllBuiltinBounties()
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				DisableBearsBounties();
				DisableFriendliesBounties();
				DisableMonsterLabZBounties();
				DisableMonsternomiconBounties();
				DisableRRRMonsterBounties();
				DisableSupplementalRaidsBounties();
				DisableVanillaBounties();
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		private void CreateBountiesPatchs()
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				string text = "adventuredata.json";
				Log.Debug(Instance, "Creating Patch files for bounties.");
				Log.Trace(Instance, $"_bountiesList == null : {_bountiesList == null}");
				if (_bountiesList == null)
				{
					return;
				}
				Log.Trace(Instance, $"_bountiesList.Count : {_bountiesList.Count}");
				foreach (AbstractBounties bounties in _bountiesList)
				{
					Log.Trace(Instance, "bountiesCollection.GetType().FullName : " + bounties.GetType().FullName);
					Log.Trace(Instance, $"bountiesCollection.IsDependenciesResolved : {bounties.IsDependenciesResolved}");
					if (!bounties.IsDependenciesResolved)
					{
						continue;
					}
					FileInfo fileInfo = new FileInfo(Path.Combine(_patchPath, bounties.GetType().Name + "_" + text));
					BountyTargetConfigExtensions.DigitalrootPatchFile digitalrootPatchFile = new BountyTargetConfigExtensions.DigitalrootPatchFile
					{
						Author = "Digitalroot",
						TargetFile = text,
						Priority = 100,
						RequireAll = true,
						Patches = new List<BountyTargetConfigExtensions.DigitalrootPatch>()
					};
					foreach (Biome item in Enum.GetValues(typeof(Biome)).Cast<Biome>())
					{
						List<BountyTargetConfig> list = bounties.GetBounties(item)?.ToList();
						if (list == null)
						{
							continue;
						}
						Log.Debug(Instance, $"Adding {list.Count} bounties for {item}");
						foreach (BountyTargetConfig item2 in list.Where((BountyTargetConfig b) => !b.TargetID.StartsWith("RRRN_")))
						{
							digitalrootPatchFile.Patches.Add(item2.ToPatch((PatchAction)4));
						}
					}
					if (!Directory.Exists(fileInfo.DirectoryName))
					{
						Directory.CreateDirectory(fileInfo.DirectoryName ?? throw new InvalidOperationException("DirectoryName is null."));
					}
					File.WriteAllText(fileInfo.FullName, digitalrootPatchFile.ToJson());
					Log.Debug(Instance, $"Wrote {digitalrootPatchFile.Patches.Count} bounties to {fileInfo.FullName}.");
				}
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		[Conditional("DEBUG")]
		[UsedImplicitly]
		private static void PrintBounties()
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				Log.Trace(Instance, $"Loaded Bounties: {Bounties.Count}");
				Log.Trace(Instance, "*******************************");
				foreach (BountyTargetConfig bounty in Bounties)
				{
					Log.Trace(Instance, "TargetID: " + bounty.TargetID);
					Log.Trace(Instance, $"Biome: {bounty.Biome}");
					Log.Trace(Instance, $"RewardCoins: {bounty.RewardCoins}");
					Log.Trace(Instance, $"RewardIron: {bounty.RewardIron}");
					Log.Trace(Instance, $"RewardGold: {bounty.RewardGold}");
					Log.Trace(Instance, "[Adds]");
					Log.Trace(Instance, $"Adds.Count: {bounty.Adds.Count}");
					foreach (BountyTargetAddConfig add in bounty.Adds)
					{
						Log.Trace(Instance, "Add.ID: " + add.ID);
						Log.Trace(Instance, $"Add.Count: {add.Count}");
					}
					Log.Trace(Instance, "*******************************");
				}
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		[Conditional("DEBUG")]
		[UsedImplicitly]
		private static void PrintBountiesTable()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				Log.Trace(Instance, $"Loaded Bounties: {Bounties.Count}");
				Log.Trace(Instance, "*******************************");
				foreach (Biome biome in Enum.GetValues(typeof(Biome)).Cast<Biome>())
				{
					Log.Trace(Instance, $"## {biome}");
					Log.Trace(Instance, "<table>");
					Log.Trace(Instance, "<tr><th>TargetID</th><th>Iron</th><th>Gold</th><th>Coins</th><th>Adds</th></tr>");
					foreach (BountyTargetConfig item in Bounties.Where((BountyTargetConfig b) => b.Biome == biome))
					{
						Log.Trace(Instance, string.Format("<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td></tr>", item.TargetID, item.RewardIron, item.RewardGold, item.RewardCoins, (item.Adds.Count == 0) ? ":x:" : ":heavy_check_mark:"));
					}
					Log.Trace(Instance, "</table>");
					Log.Trace(Instance, Environment.NewLine);
				}
				Log.Trace(Instance, "*******************************");
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		[Obsolete]
		private void AddBounties()
		{
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				if (!EpicLoot.IsAdventureModeEnabled())
				{
					return;
				}
				Log.Debug(Instance, "Adding Bounties to EpicLoot");
				Log.Trace(Instance, $"_bountiesList == null : {_bountiesList == null}");
				if (_bountiesList == null)
				{
					return;
				}
				Log.Trace(Instance, $"_bountiesList.Count : {_bountiesList.Count}");
				foreach (AbstractBounties bounties in _bountiesList)
				{
					Log.Trace(Instance, "bountiesCollection.GetType().FullName : " + bounties.GetType().FullName);
					Log.Trace(Instance, $"bountiesCollection.IsDependenciesResolved : {bounties.IsDependenciesResolved}");
					Log.Trace(Instance, $"bountiesCollection.IsLoaded : {bounties.IsLoaded}");
					if (bounties.IsLoaded || !bounties.IsDependenciesResolved)
					{
						continue;
					}
					foreach (Biome item in Enum.GetValues(typeof(Biome)).Cast<Biome>())
					{
						List<BountyTargetConfig> list = bounties.GetBounties(item)?.ToList();
						if (list != null)
						{
							Log.Debug(Instance, $"Adding {list.Count} bounties for {item}");
							Bounties.AddRange(list.Where((BountyTargetConfig b) => !b.TargetID.StartsWith("RRRN_")));
						}
					}
					bounties.OnLoaded();
				}
				_bountiesCount = Bounties.Count;
				Log.Debug(Instance, $"Loaded Bounties: {_bountiesCount}");
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		[Obsolete]
		private void ClearBounties()
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				Log.Debug(Instance, $"Removing default bounties: {Bounties.Count}");
				Bounties.Clear();
				Log.Debug(Instance, $"Bounties should be cleared: {Bounties.Count}");
				Log.Debug(Instance, $"Removing bounties from internal _bountiesList: {_bountiesList.Count}");
				_bountiesList.Clear();
				Log.Debug(Instance, $"_bountiesList should be cleared: {_bountiesList.Count}");
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}

		[Obsolete]
		private bool IsBountyListCurrent(out IEnumerable<AbstractBounties> missingBounties)
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				Log.Trace(Instance, $"[{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}] _bountiesCount == 0 : {_bountiesCount == 0}");
				Log.Trace(Instance, $"[{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}] _bountiesCount != Bounties.Count : {_bountiesCount != Bounties.Count}");
				Log.Trace(Instance, $"[{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}] _bountiesCount : {_bountiesCount}");
				Log.Trace(Instance, $"[{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}] Bounties.Count : {Bounties.Count}");
				Log.Trace(Instance, $"[{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}] _bountiesList.Any(bounties => !bounties.IsLoaded && bounties.IsDependenciesResolved) : {_bountiesList.Any((AbstractBounties bounties) => !bounties.IsLoaded && bounties.IsDependenciesResolved)}");
				missingBounties = _bountiesList.Where((AbstractBounties bounties) => !bounties.IsLoaded && bounties.IsDependenciesResolved);
				foreach (AbstractBounties missingBounty in missingBounties)
				{
					Log.Trace(Instance, "[" + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "] Missing bounties for : " + missingBounty.GetType().Name);
				}
				if (_bountiesList.Any((AbstractBounties bounties) => !bounties.IsLoaded && bounties.IsDependenciesResolved))
				{
					return false;
				}
				return _bountiesCount != 0 && _bountiesCount == Bounties.Count;
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
			missingBounties = null;
			return false;
		}

		[Obsolete]
		public void OnStoreGuiShow(ref StoreGui storeGui)
		{
			try
			{
				Log.Trace(Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
				Transform val = ((Component)storeGui).transform.Find("MerchantPanel");
				if ((Object)(object)val == (Object)null)
				{
					Log.Debug(Instance, "[" + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "] MerchantPanel not ready - skipping");
				}
				else
				{
					GameObjectExtensions.RequireComponent<MerchantPanelLoader>(((Component)val).gameObject).MerchantPanelCmb = ((Component)val).GetComponent<MerchantPanel>();
				}
			}
			catch (Exception e)
			{
				Log.Error(Instance, e);
			}
		}
	}
	[UsedImplicitly]
	public class Patch
	{
		[HarmonyBefore(new string[] { "org.bepinex.plugins.foodstaminaregen" })]
		[HarmonyAfter(new string[] { "randyknapp.mods.epicloot", "som.Bears", "DYBAssets" })]
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public class PatchZNetSceneAwake
		{
			[UsedImplicitly]
			[HarmonyPostfix]
			[HarmonyPriority(400)]
			public static void Postfix([NotNull] ref ZNetScene __instance)
			{
				try
				{
					Log.Trace(Main.Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
					if (!Utils.IsZNetSceneReady())
					{
						Log.Debug(Main.Instance, "[" + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "] ObjectDB not ready - skipping");
					}
					else
					{
						Main.Instance.OnPatchZNetSceneAwake(ref __instance);
					}
				}
				catch (Exception e)
				{
					Log.Error(Main.Instance, e);
				}
			}
		}
	}
	public class SoftDependencies
	{
		public bool Bears { get; }

		public bool Friendlies
		{
			get
			{
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					return (Object)(object)ZNetScene.instance.GetPrefab(Digitalroot.Valheim.Common.Names.FriendliesMod.PrefabNames.Ashe) != (Object)null;
				}
				return false;
			}
		}

		public bool MonsterLabZ { get; }

		public bool Monsternomicon => (Object)(object)ZNetScene.instance.GetPrefab(Digitalroot.Valheim.Common.Names.MonsternomiconMod.PrefabNames.AngryFrozenCorpse) != (Object)null;

		public bool RRRCore { get; }

		public bool RRRMonsters { get; }

		public bool RRRNpcs { get; }

		public bool SpawnThat { get; }

		public bool SupplementalRaids
		{
			get
			{
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					return (Object)(object)ZNetScene.instance.GetPrefab(Digitalroot.Valheim.Common.Names.SupplementalRaidsMod.PrefabNames.EikthyrBoar) != (Object)null;
				}
				return false;
			}
		}

		public SoftDependencies()
		{
			Bears = Utils.DoesPluginExist("som.Bears");
			MonsterLabZ = Utils.DoesPluginExist("MonsterLabZ");
			RRRCore = Utils.DoesPluginExist("com.alexanderstrada.rrrcore");
			RRRNpcs = Utils.DoesPluginExist("com.alexanderstrada.rrrnpcs");
			RRRMonsters = Utils.DoesPluginExist("com.alexanderstrada.rrrmonsters");
			SpawnThat = Utils.DoesPluginExist("asharppen.valheim.spawn_that");
		}

		public override string ToString()
		{
			return "Soft Dependencies " + Environment.NewLine + string.Format("{0} : {1}{2}", "Bears", Bears, Environment.NewLine) + string.Format("{0} : {1}{2}", "Friendlies", Friendlies, Environment.NewLine) + string.Format("{0} : {1}{2}", "MonsterLabZ", MonsterLabZ, Environment.NewLine) + string.Format("{0} : {1}{2}", "Monsternomicon", Monsternomicon, Environment.NewLine) + string.Format("{0} : {1}{2}", "RRRCore", RRRCore, Environment.NewLine) + string.Format("{0} : {1}{2}", "RRRNpcs", RRRNpcs, Environment.NewLine) + string.Format("{0} : {1}{2}", "RRRMonsters", RRRMonsters, Environment.NewLine) + string.Format("{0} : {1}{2}", "SpawnThat", SpawnThat, Environment.NewLine) + string.Format("{0} : {1}{2}", "SupplementalRaids", SupplementalRaids, Environment.NewLine);
		}
	}
}
namespace Digitalroot.Valheim.Bounties.Providers
{
	public abstract class AbstractBounties
	{
		private readonly Func<Biome, IEnumerable<string>> _bossNames;

		private readonly Func<Biome, IEnumerable<string>> _enemyNames;

		public virtual bool IsDependenciesResolved { get; protected set; }

		public bool IsLoaded { get; private set; }

		protected AbstractBounties()
		{
		}

		protected AbstractBounties(Func<Biome, IEnumerable<string>> enemyNames = null, Func<Biome, IEnumerable<string>> bossNames = null)
		{
			_enemyNames = enemyNames;
			_bossNames = bossNames;
		}

		public void OnLoaded()
		{
			Log.Trace(Main.Instance, "Digitalroot.ValheimBounties." + MethodBase.GetCurrentMethod()?.DeclaringType?.Name + "." + MethodBase.GetCurrentMethod()?.Name);
			IsLoaded = true;
		}

		protected virtual int GetCoins(Biome biome, uint add = 0u)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			int num;
			if ((int)biome <= 32)
			{
				switch ((int)biome)
				{
				case 1:
					goto IL_0052;
				case 8:
					goto IL_0057;
				case 2:
					goto IL_005c;
				case 4:
					goto IL_0061;
				case 0:
					goto IL_007f;
				case 3:
				case 5:
				case 6:
				case 7:
					goto IL_0083;
				}
				if ((int)biome != 16)
				{
					if ((int)biome != 32)
					{
						goto IL_0083;
					}
					num = 70;
				}
				else
				{
					num = 50;
				}
			}
			else if ((int)biome != 64)
			{
				if ((int)biome != 256)
				{
					if ((int)biome != 512)
					{
						goto IL_0083;
					}
					num = 60;
				}
				else
				{
					num = 30;
				}
			}
			else
			{
				num = 80;
			}
			goto IL_0085;
			IL_005c:
			num = 30;
			goto IL_0085;
			IL_007f:
			num = 1;
			goto IL_0085;
			IL_0052:
			num = 10;
			goto IL_0085;
			IL_0085:
			int num2 = num;
			return Convert.ToInt16(add) + num2;
			IL_0083:
			num = 1;
			goto IL_0085;
			IL_0057:
			num = 20;
			goto IL_0085;
			IL_0061:
			num = 40;
			goto IL_0085;
		}

		protected virtual int GetIron(Biome biome, uint add = 0u)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			int num;
			if ((int)biome <= 32)
			{
				switch ((int)biome)
				{
				case 1:
					goto IL_0052;
				case 8:
					goto IL_0056;
				case 2:
					goto IL_005a;
				case 4:
					goto IL_005e;
				case 0:
					goto IL_0076;
				case 3:
				case 5:
				case 6:
				case 7:
					goto IL_007a;
				}
				if ((int)biome != 16)
				{
					if ((int)biome != 32)
					{
						goto IL_007a;
					}
					num = 6;
				}
				else
				{
					num = 5;
				}
			}
			else if ((int)biome != 64)
			{
				if ((int)biome != 256)
				{
					if ((int)biome != 512)
					{
						goto IL_007a;
					}
					num = 5;
				}
				else
				{
					num = 4;
				}
			}
			else
			{
				num = 7;
			}
			goto IL_007c;
			IL_005a:
			num = 3;
			goto IL_007c;
			IL_0076:
			num = 0;
			goto IL_007c;
			IL_0052:
			num = 1;
			goto IL_007c;
			IL_007c:
			int num2 = num;
			return Convert.ToInt16(add) + num2;
			IL_007a:
			num = 0;
			goto IL_007c;
			IL_0056:
			num = 2;
			goto IL_007c;
			IL_005e:
			num = 4;
			goto IL_007c;
		}

		protected virtual int GetGold(Biome biome, uint add = 0u)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			int num;
			if ((int)biome <= 32)
			{
				switch ((int)biome)
				{
				case 1:
					goto IL_0052;
				case 8:
					goto IL_0056;
				case 2:
					goto IL_005a;
				case 4:
					goto IL_005e;
				case 0:
					goto IL_0076;
				case 3:
				case 5:
				case 6:
				case 7:
					goto IL_007a;
				}
				if ((int)biome != 16)
				{
					if ((int)biome != 32)
					{
						goto IL_007a;
					}
					num = 2;
				}
				else
				{
					num = 1;
				}
			}
			else if ((int)biome != 64)
			{
				if ((int)biome != 256)
				{
					if ((int)biome != 512)
					{
						goto IL_007a;
					}
					num = 1;
				}
				else
				{
					num = 0;
				}
			}
			else
			{
				num = 2;
			}
			goto IL_007c;
			IL_005a:
			num = 0;
			goto IL_007c;
			IL_0076:
			num = 0;
			goto IL_007c;
			IL_0052:
			num = 0;
			goto IL_007c;
			IL_007c:
			int num2 = num;
			return Convert.ToInt16(add) + num2;
			IL_007a:
			num = 0;
			goto IL_007c;
			IL_0056:
			num = 0;
			goto IL_007c;
			IL_005e:
			num = 0;
			goto IL_007c;
		}

		public IEnumerable<BountyTargetConfig> GetBounties(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			if ((int)biome <= 32)
			{
				switch ((int)biome)
				{
				default:
					if ((int)biome != 16)
					{
						if ((int)biome != 32)
						{
							break;
						}
						return GetAshLandsBounties();
					}
					return GetPlainsBounties();
				case 1:
					return GetMeadowsBounties();
				case 8:
					return GetBlackForestBounties();
				case 2:
					return GetSwampBounties();
				case 4:
					return GetMountainBounties();
				case 0:
					return null;
				case 3:
				case 5:
				case 6:
				case 7:
					break;
				}
			}
			else
			{
				if ((int)biome == 64)
				{
					return GetDeepNorthBounties();
				}
				if ((int)biome == 256)
				{
					return GetOceanBounties();
				}
				if ((int)biome == 512)
				{
					return GetMistlandsBounties();
				}
			}
			return null;
		}

		private IEnumerable<BountyTargetConfig> GetBountiesByBiome(Biome biome)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (_enemyNames != null)
			{
				foreach (string item in _enemyNames(biome))
				{
					yield return new BountyTargetConfig
					{
						TargetID = item,
						Biome = biome,
						RewardCoins = GetCoins(biome),
						RewardIron = GetIron(biome),
						RewardGold = GetGold(biome)
					};
				}
			}
			if (_bossNames == null)
			{
				yield break;
			}
			foreach (string item2 in _bossNames(biome))
			{
				yield return new BountyTargetConfig
				{
					TargetID = item2,
					Biome = biome,
					RewardCoins = GetCoins(biome),
					RewardIron = GetIron(biome),
					RewardGold = GetGold(biome)
				};
			}
		}

		protected virtual IEnumerable<BountyTargetConfig> FilterResults(IEnumerable<BountyTargetConfig> bountyTargetConfigs)
		{
			return bountyTargetConfigs;
		}

		protected virtual IEnumerable<BountyTargetConfig> GetMeadowsBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)1));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetBlackForestBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)8));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetSwampBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)2));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetMountainBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)4));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetPlainsBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)16));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetOceanBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)256));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetMistlandsBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)512));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetAshLandsBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)32));
		}

		protected virtual IEnumerable<BountyTargetConfig> GetDeepNorthBounties()
		{
			return FilterResults(GetBountiesByBiome((Biome)64));
		}
	}
	public class BearsBounties : AbstractBounties
	{
		public override bool IsDependenciesResolved => Main.Instance.SoftDependencies.Bears;

		public BearsBounties()
			: base(Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.AllNamesByBiome)
		{
		}

		protected override IEnumerable<BountyTargetConfig> GetMountainBounties()
		{
			for (int i = 0; i < 3; i++)
			{
				yield return new BountyTargetConfig
				{
					TargetID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
					Biome = (Biome)4,
					RewardCoins = GetCoins((Biome)4, 10u),
					RewardIron = GetIron((Biome)4),
					RewardGold = GetGold((Biome)4)
				};
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4, 1u),
				RewardGold = GetGold((Biome)4),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.BearCub,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.BearCub,
						Count = 4
					}
				}
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetDeepNorthBounties()
		{
			for (int i = 0; i < 2; i++)
			{
				yield return new BountyTargetConfig
				{
					TargetID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
					Biome = (Biome)64,
					RewardCoins = GetCoins((Biome)64, 10u),
					RewardIron = GetIron((Biome)64),
					RewardGold = GetGold((Biome)64)
				};
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
				Biome = (Biome)64,
				RewardCoins = GetCoins((Biome)64),
				RewardIron = GetIron((Biome)64, 1u),
				RewardGold = GetGold((Biome)64),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.BearCub,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
				Biome = (Biome)64,
				RewardCoins = GetCoins((Biome)64),
				RewardIron = GetIron((Biome)64),
				RewardGold = GetGold((Biome)64, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.Bear,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.BearsMod.EnemyNames.BearCub,
						Count = 4
					}
				}
			};
		}
	}
	public class DebugBounties : AbstractBounties
	{
		public override bool IsDependenciesResolved => true;

		protected override IEnumerable<BountyTargetConfig> FilterResults(IEnumerable<BountyTargetConfig> bountyTargetConfigs)
		{
			return null;
		}

		[UsedImplicitly]
		private BountyTargetConfig CreateBountyTargetConfig(Biome biome, string name)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			return new BountyTargetConfig
			{
				Biome = biome,
				RewardCoins = 0,
				RewardGold = 0,
				RewardIron = 0,
				TargetID = name
			};
		}
	}
	public class MonsterLabZBounties : AbstractBounties
	{
		public override bool IsDependenciesResolved => Main.Instance.SoftDependencies.MonsterLabZ;

		public MonsterLabZBounties()
			: base(Digitalroot.Valheim.Common.Names.MonsterLabZMod.EnemyNames.AllNamesByBiome, Digitalroot.Valheim.Common.Names.MonsterLabZMod.BossNames.AllNamesByBiome)
		{
		}

		protected override IEnumerable<BountyTargetConfig> FilterResults(IEnumerable<BountyTargetConfig> bountyTargetConfigs)
		{
			return from target in bountyTargetConfigs
				where !target.TargetID.Equals(Digitalroot.Valheim.Common.Names.MonsterLabZMod.EnemyNames.RainbowButterfly)
				where !target.TargetID.Equals(Digitalroot.Valheim.Common.Names.MonsterLabZMod.EnemyNames.SilkwormButterfly)
				where !target.TargetID.Equals(Digitalroot.Valheim.Common.Names.MonsterLabZMod.EnemyNames.BlackSpider)
				where !target.TargetID.Equals(Digitalroot.Valheim.Common.Names.MonsterLabZMod.EnemyNames.GoblinBoat)
				where !target.TargetID.Equals(Digitalroot.Valheim.Common.Names.MonsterLabZMod.EnemyNames.GoblinShip2)
				select target;
		}
	}
	public class MonsternomiconBounties : AbstractBounties
	{
		public override bool IsDependenciesResolved => Main.Instance.SoftDependencies.Monsternomicon;

		public MonsternomiconBounties()
			: base(Digitalroot.Valheim.Common.Names.MonsternomiconMod.EnemyNames.AllNamesByBiome, Digitalroot.Valheim.Common.Names.MonsternomiconMod.BossNames.AllNamesByBiome)
		{
		}

		protected override IEnumerable<BountyTargetConfig> FilterResults(IEnumerable<BountyTargetConfig> bountyTargetConfigs)
		{
			return from target in bountyTargetConfigs
				where !target.TargetID.Equals(Digitalroot.Valheim.Common.Names.MonsternomiconMod.EnemyNames.AngrySpirit)
				where !target.TargetID.Equals(Digitalroot.Valheim.Common.Names.MonsternomiconMod.EnemyNames.CalmSpirit)
				select target;
		}
	}
	public class RRRMonsterBounties : AbstractBounties
	{
		public override bool IsDependenciesResolved
		{
			get
			{
				if (Main.Instance.SoftDependencies.RRRCore)
				{
					return Main.Instance.SoftDependencies.RRRMonsters;
				}
				return false;
			}
		}

		public RRRMonsterBounties()
			: base(Digitalroot.Valheim.Common.Names.RRRMod.EnemyNames.AllNamesByBiome)
		{
		}

		protected override IEnumerable<BountyTargetConfig> GetBlackForestBounties()
		{
			foreach (BountyTargetConfig blackForestBounty in base.GetBlackForestBounties())
			{
				blackForestBounty.RewardCoins = GetCoins((Biome)8, 10u);
				blackForestBounty.RewardIron = GetIron((Biome)8, 1u);
				yield return blackForestBounty;
			}
		}

		protected override IEnumerable<BountyTargetConfig> GetMistlandsBounties()
		{
			foreach (BountyTargetConfig mistlandsBounty in base.GetMistlandsBounties())
			{
				mistlandsBounty.RewardCoins = GetCoins((Biome)512, 40u);
				mistlandsBounty.RewardIron = GetIron((Biome)512, 2u);
				mistlandsBounty.RewardGold = GetGold((Biome)512, 1u);
				yield return mistlandsBounty;
			}
		}
	}
	public class SupplementalRaidsBounties : AbstractBounties
	{
		public override bool IsDependenciesResolved => Main.Instance.SoftDependencies.SupplementalRaids;

		public SupplementalRaidsBounties()
			: base(Digitalroot.Valheim.Common.Names.SupplementalRaidsMod.EnemyNames.AllNamesByBiome, Digitalroot.Valheim.Common.Names.SupplementalRaidsMod.BossNames.AllNamesByBiome)
		{
		}
	}
	public class VanillaBounties : AbstractBounties
	{
		public override bool IsDependenciesResolved => true;

		public VanillaBounties()
			: base(Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.AllNamesByBiome, Digitalroot.Valheim.Common.Names.Vanilla.BossNames.AllNamesByBiome)
		{
		}

		protected override IEnumerable<BountyTargetConfig> GetMeadowsBounties()
		{
			foreach (BountyTargetConfig meadowsBounty in base.GetMeadowsBounties())
			{
				yield return meadowsBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Deer,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Boar,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Boar,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Neck,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Neck,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greyling,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greyling,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Boar,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 5u),
				RewardIron = GetIron((Biome)1, 1u),
				RewardGold = GetGold((Biome)1),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Boar,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Neck,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 5u),
				RewardIron = GetIron((Biome)1, 1u),
				RewardGold = GetGold((Biome)1),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Neck,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GreydwarfShaman,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 15u),
				RewardIron = GetIron((Biome)1, 1u),
				RewardGold = GetGold((Biome)1, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greyling,
						Count = 4
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GreydwarfElite,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 90u),
				RewardIron = GetIron((Biome)1, 9u),
				RewardGold = GetGold((Biome)1, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GreydwarfShaman,
						Count = 2
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greydwarf,
						Count = 4
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greyling,
						Count = 5
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 15u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)1, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.SkeletonPoison,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 15u),
				RewardIron = GetIron((Biome)1, 4u),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.SkeletonPoison,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 20u),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 4
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 40u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)1, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 10u),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 10u),
				RewardIron = GetIron((Biome)1),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 40u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)1, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Lox,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 40u),
				RewardIron = GetIron((Biome)1, 2u),
				RewardGold = GetGold((Biome)1)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 90u),
				RewardIron = GetIron((Biome)1, 2u),
				RewardGold = GetGold((Biome)1, 2u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 110u),
				RewardIron = GetIron((Biome)1, 4u),
				RewardGold = GetGold((Biome)1, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 110u),
				RewardIron = GetIron((Biome)1, 4u),
				RewardGold = GetGold((Biome)1, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Boar,
						Count = 5
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Neck,
						Count = 5
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)1,
				RewardCoins = GetCoins((Biome)1, 150u),
				RewardIron = GetIron((Biome)1, 7u),
				RewardGold = GetGold((Biome)1, 5u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Boar,
						Count = 5
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Neck,
						Count = 5
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 2
					}
				}
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetBlackForestBounties()
		{
			Biome biome = (Biome)8;
			foreach (BountyTargetConfig blackForestBounty in base.GetBlackForestBounties())
			{
				yield return blackForestBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greydwarf,
				Biome = biome,
				RewardCoins = GetCoins(biome),
				RewardIron = GetIron(biome),
				RewardGold = GetGold(biome)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greydwarf,
				Biome = biome,
				RewardCoins = GetCoins(biome),
				RewardIron = GetIron(biome),
				RewardGold = GetGold(biome)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = biome,
				RewardCoins = GetCoins(biome),
				RewardIron = GetIron(biome),
				RewardGold = GetGold(biome)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = biome,
				RewardCoins = GetCoins(biome),
				RewardIron = GetIron(biome),
				RewardGold = GetGold(biome)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = biome,
				RewardCoins = GetCoins(biome, 5u),
				RewardIron = GetIron(biome),
				RewardGold = GetGold(biome)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GreydwarfShaman,
				Biome = biome,
				RewardCoins = GetCoins(biome, 10u),
				RewardIron = GetIron(biome, 1u),
				RewardGold = GetGold(biome)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = biome,
				RewardCoins = GetCoins(biome, 15u),
				RewardIron = GetIron(biome, 2u),
				RewardGold = GetGold(biome),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GreydwarfElite,
				Biome = biome,
				RewardCoins = GetCoins(biome, 5u),
				RewardIron = 0,
				RewardGold = GetGold(biome, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,
				Biome = biome,
				RewardCoins = GetCoins(biome, 35u),
				RewardIron = 0,
				RewardGold = GetGold(biome, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GreydwarfShaman,
				Biome = biome,
				RewardCoins = GetCoins(biome, 25u),
				RewardIron = GetIron(biome, 2u),
				RewardGold = GetGold(biome, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Greydwarf,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = biome,
				RewardCoins = GetCoins(biome, 165u),
				RewardIron = GetIron(biome, 3u),
				RewardGold = GetGold(biome, 2u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = biome,
				RewardCoins = GetCoins(biome, 185u),
				RewardIron = GetIron(biome, 5u),
				RewardGold = GetGold(biome, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = biome,
				RewardCoins = GetCoins(biome, 205u),
				RewardIron = GetIron(biome, 7u),
				RewardGold = GetGold(biome, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = biome,
				RewardCoins = GetCoins(biome, 205u),
				RewardIron = GetIron(biome, 7u),
				RewardGold = GetGold(biome, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = biome,
				RewardCoins = GetCoins(biome, 235u),
				RewardIron = GetIron(biome, 10u),
				RewardGold = GetGold(biome, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetSwampBounties()
		{
			foreach (BountyTargetConfig swampBounty in base.GetSwampBounties())
			{
				yield return swampBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Blob,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 5u),
				RewardIron = GetIron((Biome)2),
				RewardGold = GetGold((Biome)2)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 10u),
				RewardIron = GetIron((Biome)2, 1u),
				RewardGold = GetGold((Biome)2)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 15u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Blob,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 15u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Blob,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 15u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 20u),
				RewardIron = GetIron((Biome)2, 3u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 2
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.SkeletonPoison,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 15u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 15u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Draugr,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 15u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.BlobElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 15u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Draugr,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2),
				RewardIron = GetIron((Biome)2),
				RewardGold = GetGold((Biome)2)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Leech,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2),
				RewardIron = GetIron((Biome)2),
				RewardGold = GetGold((Biome)2)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2),
				RewardIron = 0,
				RewardGold = GetGold((Biome)2)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Draugr,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 10u),
				RewardIron = GetIron((Biome)2),
				RewardGold = GetGold((Biome)2)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Surtling,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2),
				RewardIron = GetIron((Biome)2),
				RewardGold = GetGold((Biome)2)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Surtling,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 10u),
				RewardIron = GetIron((Biome)2, 1u),
				RewardGold = GetGold((Biome)2),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Surtling,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 30u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)2, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 50u),
				RewardIron = GetIron((Biome)2),
				RewardGold = GetGold((Biome)2, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 30u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)2, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 60u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Draugr,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 60u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
						Count = 2
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Draugr,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 60u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrElite,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 60u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Draugr,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 30u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 5
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.SkeletonPoison,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 40u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 5
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 160u),
				RewardIron = GetIron((Biome)2, 3u),
				RewardGold = GetGold((Biome)2, 2u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 100u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 120u),
				RewardIron = GetIron((Biome)2, 2u),
				RewardGold = GetGold((Biome)2, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 180u),
				RewardIron = GetIron((Biome)2, 4u),
				RewardGold = GetGold((Biome)2, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 190u),
				RewardIron = GetIron((Biome)2, 5u),
				RewardGold = GetGold((Biome)2, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrElite,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 200u),
				RewardIron = GetIron((Biome)2, 6u),
				RewardGold = GetGold((Biome)2, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 190u),
				RewardIron = GetIron((Biome)2, 5u),
				RewardGold = GetGold((Biome)2, 4u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)2,
				RewardCoins = GetCoins((Biome)2, 220u),
				RewardIron = GetIron((Biome)2, 8u),
				RewardGold = GetGold((Biome)2, 4u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetMountainBounties()
		{
			foreach (BountyTargetConfig mountainBounty in base.GetMountainBounties())
			{
				yield return mountainBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wolf,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wolf,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Drake,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Drake,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Surtling,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 10u),
				RewardIron = GetIron((Biome)4, 1u),
				RewardGold = GetGold((Biome)4),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Fenring,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 20u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)4, 2u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Fenring,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 70u),
				RewardIron = GetIron((Biome)4, 1u),
				RewardGold = GetGold((Biome)4, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wolf,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wolf,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 40u),
				RewardIron = GetIron((Biome)4, 1u),
				RewardGold = GetGold((Biome)4, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wolf,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.StoneGolem,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 50u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)4, 2u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.StoneGolem,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 130u),
				RewardIron = GetIron((Biome)4, 3u),
				RewardGold = GetGold((Biome)4, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.StoneGolem,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 10u),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 10u),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 15u),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 15u),
				RewardIron = GetIron((Biome)4),
				RewardGold = GetGold((Biome)4)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 90u),
				RewardIron = GetIron((Biome)4, 2u),
				RewardGold = GetGold((Biome)4, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 110u),
				RewardIron = GetIron((Biome)4, 3u),
				RewardGold = GetGold((Biome)4, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 180u),
				RewardIron = GetIron((Biome)4, 3u),
				RewardGold = GetGold((Biome)4, 2u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 200u),
				RewardIron = GetIron((Biome)4, 4u),
				RewardGold = GetGold((Biome)4, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Drake,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 200u),
				RewardIron = GetIron((Biome)4, 4u),
				RewardGold = GetGold((Biome)4, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.StoneGolem,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 220u),
				RewardIron = GetIron((Biome)4, 6u),
				RewardGold = GetGold((Biome)4, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Drake,
						Count = 4
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 220u),
				RewardIron = GetIron((Biome)4, 6u),
				RewardGold = GetGold((Biome)4, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 210u),
				RewardIron = GetIron((Biome)4, 5u),
				RewardGold = GetGold((Biome)4, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)4,
				RewardCoins = GetCoins((Biome)4, 250u),
				RewardIron = GetIron((Biome)4, 7u),
				RewardGold = GetGold((Biome)4, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetPlainsBounties()
		{
			foreach (BountyTargetConfig plainsBounty in base.GetPlainsBounties())
			{
				yield return plainsBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Goblin,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 15u),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Goblin,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 15u),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Goblin,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 15u),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Drake,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Lox,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 45u),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Surtling,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.DraugrRanged,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 10u),
				RewardIron = GetIron((Biome)16, 1u),
				RewardGold = GetGold((Biome)16),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Deathsquito,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Deathsquito,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Deathsquito,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 15u),
				RewardIron = GetIron((Biome)16, 3u),
				RewardGold = GetGold((Biome)16, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Deathsquito,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GoblinBrute,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 45u),
				RewardIron = 0,
				RewardGold = GetGold((Biome)16, 3u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GoblinBrute,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 85u),
				RewardIron = GetIron((Biome)16, 3u),
				RewardGold = GetGold((Biome)16, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Goblin,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GoblinBrute,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 145u),
				RewardIron = GetIron((Biome)16, 5u),
				RewardGold = GetGold((Biome)16, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Goblin,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GoblinShaman,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 165u),
				RewardIron = GetIron((Biome)16, 5u),
				RewardGold = GetGold((Biome)16, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Goblin,
						Count = 3
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GoblinShaman,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 215u),
				RewardIron = GetIron((Biome)16, 10u),
				RewardGold = GetGold((Biome)16, 4u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.GoblinBrute,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Goblin,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 30u),
				RewardIron = GetIron((Biome)16),
				RewardGold = GetGold((Biome)16, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 40u),
				RewardIron = GetIron((Biome)16, 3u),
				RewardGold = GetGold((Biome)16, 1u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 50u),
				RewardIron = GetIron((Biome)16, 5u),
				RewardGold = GetGold((Biome)16, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 180u),
				RewardIron = GetIron((Biome)16, 4u),
				RewardGold = GetGold((Biome)16, 2u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Drake,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 250u),
				RewardIron = GetIron((Biome)16, 7u),
				RewardGold = GetGold((Biome)16, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 350u),
				RewardIron = GetIron((Biome)16, 10u),
				RewardGold = GetGold((Biome)16, 6u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 350u),
				RewardIron = GetIron((Biome)16, 10u),
				RewardGold = GetGold((Biome)16, 6u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 300u),
				RewardIron = GetIron((Biome)16, 10u),
				RewardGold = GetGold((Biome)16, 4u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 320u),
				RewardIron = GetIron((Biome)16, 15u),
				RewardGold = GetGold((Biome)16, 5u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 500u),
				RewardIron = GetIron((Biome)16, 20u),
				RewardGold = GetGold((Biome)16, 6u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 500u),
				RewardIron = GetIron((Biome)16, 10u),
				RewardGold = GetGold((Biome)16, 3u)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 530u),
				RewardIron = GetIron((Biome)16, 12u),
				RewardGold = GetGold((Biome)16, 3u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 600u),
				RewardIron = GetIron((Biome)16, 20u),
				RewardGold = GetGold((Biome)16, 4u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 800u),
				RewardIron = GetIron((Biome)16, 30u),
				RewardGold = GetGold((Biome)16, 8u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 800u),
				RewardIron = GetIron((Biome)16, 30u),
				RewardGold = GetGold((Biome)16, 8u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 1000u),
				RewardIron = GetIron((Biome)16, 40u),
				RewardGold = GetGold((Biome)16, 10u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 1000u),
				RewardIron = GetIron((Biome)16, 40u),
				RewardGold = GetGold((Biome)16, 10u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 1200u),
				RewardIron = GetIron((Biome)16, 50u),
				RewardGold = GetGold((Biome)16, 12u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 1250u),
				RewardIron = GetIron((Biome)16, 60u),
				RewardGold = GetGold((Biome)16, 13u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 1400u),
				RewardIron = GetIron((Biome)16, 70u),
				RewardGold = GetGold((Biome)16, 15u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Yagluth,
				Biome = (Biome)16,
				RewardCoins = GetCoins((Biome)16, 2000u),
				RewardIron = GetIron((Biome)16, 75u),
				RewardGold = GetGold((Biome)16, 15u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Moder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.TheElder,
						Count = 1
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 1
					}
				}
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetOceanBounties()
		{
			foreach (BountyTargetConfig oceanBounty in base.GetOceanBounties())
			{
				yield return oceanBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Serpent,
				Biome = (Biome)256,
				RewardCoins = GetCoins((Biome)256),
				RewardIron = GetIron((Biome)256, 2u),
				RewardGold = GetGold((Biome)256, 1u)
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetMistlandsBounties()
		{
			foreach (BountyTargetConfig mistlandsBounty in base.GetMistlandsBounties())
			{
				yield return mistlandsBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)512,
				RewardCoins = GetCoins((Biome)512),
				RewardIron = GetIron((Biome)512),
				RewardGold = GetGold((Biome)512),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
						Count = 2
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
				Biome = (Biome)512,
				RewardCoins = GetCoins((Biome)512),
				RewardIron = GetIron((Biome)512),
				RewardGold = GetGold((Biome)512),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
						Count = 2
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)512,
				RewardCoins = GetCoins((Biome)512),
				RewardIron = GetIron((Biome)512),
				RewardGold = GetGold((Biome)512),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
						Count = 4
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Wraith,
				Biome = (Biome)512,
				RewardCoins = GetCoins((Biome)512),
				RewardIron = GetIron((Biome)512),
				RewardGold = GetGold((Biome)512),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Ghost,
						Count = 2
					},
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Skeleton,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
				Biome = (Biome)512,
				RewardCoins = GetCoins((Biome)512, 30u),
				RewardIron = GetIron((Biome)512),
				RewardGold = GetGold((Biome)512),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 5
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.SeekerQueen,
				Biome = (Biome)512,
				RewardCoins = GetCoins((Biome)512, 30u),
				RewardIron = GetIron((Biome)512),
				RewardGold = GetGold((Biome)512),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Eikthyr,
						Count = 5
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.SeekerQueen,
				Biome = (Biome)512,
				RewardCoins = GetCoins((Biome)512, 30u),
				RewardIron = GetIron((Biome)512),
				RewardGold = GetGold((Biome)512),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.BossNames.Bonemass,
						Count = 1
					}
				}
			};
		}

		protected override IEnumerable<BountyTargetConfig> GetDeepNorthBounties()
		{
			foreach (BountyTargetConfig deepNorthBounty in base.GetDeepNorthBounties())
			{
				yield return deepNorthBounty;
			}
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,
				Biome = (Biome)64,
				RewardCoins = GetCoins((Biome)64),
				RewardIron = GetIron((Biome)64),
				RewardGold = GetGold((Biome)64)
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,
				Biome = (Biome)64,
				RewardCoins = GetCoins((Biome)64, 10u),
				RewardIron = GetIron((Biome)64, 1u),
				RewardGold = GetGold((Biome)64, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,
						Count = 1
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,
				Biome = (Biome)64,
				RewardCoins = GetCoins((Biome)64, 20u),
				RewardIron = GetIron((Biome)64, 3u),
				RewardGold = GetGold((Biome)64, 1u),
				Adds = new List<BountyTargetAddConfig>
				{
					new BountyTargetAddConfig
					{
						ID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,
						Count = 2
					}
				}
			};
			yield return new BountyTargetConfig
			{
				TargetID = Digitalroot.Valheim.Common.Names.Vanilla.EnemyNames.Troll,