using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using DG.Tweening;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Sayrus.HelperFarmer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+76210269d08fb7dbed9ab298629a3b8bc4cd014d")]
[assembly: AssemblyProduct("Helper Farmer")]
[assembly: AssemblyTitle("Sayrus.HelperFarmer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Sayrus.HelperFarmer
{
	public class Utils
	{
		public static ushort CLEANER_HOUSE_ID = 1156;

		public static ushort FARMER_HOUSE_ID = 8765;

		public static ushort FERTILIZER_ID = 280;

		public static ushort HOE_PRO_ID = 307;

		public static ushort HOE_ID = 302;

		public static ushort WATER_CAN_ID = 303;

		public static bool IsHoe(Item item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return item.dataId == HOE_ID || item.dataId == HOE_PRO_ID;
		}
	}
	public class HelperFarmerFarmState : StateBase<HelperCleanerStateMachine>
	{
		[CompilerGenerated]
		private sealed class <FarmGardenBedAfterDelay>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GardenBed gardenBed;

			public Item hoe;

			public HelperFarmerFarmState <>4__this;

			private ItemData <data>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FarmGardenBedAfterDelay>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<data>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Invalid comparison between Unknown and I4
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					<data>5__1 = null;
					break;
				}
				if ((int)gardenBed.state.Value == 0)
				{
					gardenBed.PlowBedServerRpc((byte)1);
					ItemManager.Instance.GetItemData((uint)hoe.dataId, ref <data>5__1);
					if (hoe.durability > <data>5__1.durabilityPerHit)
					{
						hoe.durability -= <data>5__1.durabilityPerHit;
						((HelperBase)<>4__this.Owner).containerRef.containerNet.SetItemById(hoe.id, hoe);
					}
					else
					{
						((HelperBase)<>4__this.Owner).containerRef.containerNet.RemoveItemById(hoe.id);
					}
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerIdleState(((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine));
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <FertilizeGardenBedAfterDelay>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GardenBed gardenBed;

			public HelperFarmerFarmState <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FertilizeGardenBedAfterDelay>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!gardenBed.isFertilized.Value && ((HelperBase)<>4__this.Owner).containerRef.containerNet.GetItemAmount(Utils.FERTILIZER_ID) != 0)
					{
						((HelperBase)<>4__this.Owner).containerRef.containerNet.RemoveAmount(Utils.FERTILIZER_ID, (ushort)1);
						gardenBed.isFertilized.Value = true;
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerIdleState(((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine));
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <WaterGardenBedAfterDelay>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GardenBed gardenBed;

			public Item waterCan;

			public HelperFarmerFarmState <>4__this;

			private ItemData <data>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaterGardenBedAfterDelay>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<data>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!gardenBed.isWatered.Value)
					{
						ItemManager.Instance.GetItemData((uint)waterCan.dataId, ref <data>5__1);
						if (waterCan.durability > <data>5__1.durabilityPerHit)
						{
							waterCan.durability -= <data>5__1.durabilityPerHit;
							waterCan.charge--;
							((HelperBase)<>4__this.Owner).containerRef.containerNet.SetItemById(waterCan.id, waterCan);
						}
						else
						{
							((HelperBase)<>4__this.Owner).containerRef.containerNet.RemoveItemById(waterCan.id);
						}
						gardenBed.isWatered.Value = true;
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					<data>5__1 = null;
					break;
				}
				((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerIdleState(((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine));
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public HelperTaskFarm task;

		private HelperCleaner Owner => base.stateMachine.Owner;

		public HelperFarmerFarmState(HelperCleanerStateMachine newStateMachine, HelperTaskFarm newTask)
			: base(newStateMachine)
		{
			task = newTask;
		}

		public override void ExecutePerFrame()
		{
			Owner.SetAnimatorMoveSpeed();
		}

		public override void OnEnter()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			((HelperBase)Owner).animator.SetBool("Cleanup", true);
			((HelperBase)Owner).agent.isStopped = true;
			HelperCleaner owner = Owner;
			HelperTaskFarm.TaskType taskType = task.taskType;
			if (1 == 0)
			{
			}
			IEnumerator enumerator = taskType switch
			{
				HelperTaskFarm.TaskType.Farm => FarmGardenBedAfterDelay(task.gardenBed, task.item), 
				HelperTaskFarm.TaskType.Fertilize => FertilizeGardenBedAfterDelay(task.gardenBed), 
				HelperTaskFarm.TaskType.Water => WaterGardenBedAfterDelay(task.gardenBed, task.item), 
				_ => throw new NotImplementedException("Unknown task type"), 
			};
			if (1 == 0)
			{
			}
			((MonoBehaviour)owner).StartCoroutine(enumerator);
			ShortcutExtensions.DOLookAt(((Component)Owner).transform, ((Component)task.gardenBed).transform.position, 0.5f, (AxisConstraint)4, (Vector3?)null);
		}

		[IteratorStateMachine(typeof(<FarmGardenBedAfterDelay>d__6))]
		private IEnumerator FarmGardenBedAfterDelay(GardenBed gardenBed, Item hoe)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FarmGardenBedAfterDelay>d__6(0)
			{
				<>4__this = this,
				gardenBed = gardenBed,
				hoe = hoe
			};
		}

		[IteratorStateMachine(typeof(<WaterGardenBedAfterDelay>d__7))]
		private IEnumerator WaterGardenBedAfterDelay(GardenBed gardenBed, Item waterCan)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaterGardenBedAfterDelay>d__7(0)
			{
				<>4__this = this,
				gardenBed = gardenBed,
				waterCan = waterCan
			};
		}

		[IteratorStateMachine(typeof(<FertilizeGardenBedAfterDelay>d__8))]
		private IEnumerator FertilizeGardenBedAfterDelay(GardenBed gardenBed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FertilizeGardenBedAfterDelay>d__8(0)
			{
				<>4__this = this,
				gardenBed = gardenBed
			};
		}

		public override void OnExit()
		{
			((Behaviour)((HelperBase)Owner).agent).enabled = true;
			((HelperBase)Owner).agent.isStopped = false;
			((HelperBase)Owner).animator.SetBool("Cleanup", false);
		}

		public override void ExecutePerSecond()
		{
		}
	}
	public class HelperFarmerFullInventoryState : StateBase<HelperCleanerStateMachine>
	{
		private HelperCleaner Owner => base.stateMachine.Owner;

		public HelperFarmerFullInventoryState(HelperCleanerStateMachine newStateMachine)
			: base(newStateMachine)
		{
		}

		public override void OnEnter()
		{
			Owner.SetAgentProperty((AgentStopProperty)0, false);
			((HelperBase)Owner).isInventoryFull.Value = true;
		}

		public override void OnExit()
		{
			Owner.SetAgentProperty((AgentStopProperty)0, true);
			((HelperBase)Owner).isInventoryFull.Value = false;
		}

		public override void ExecutePerFrame()
		{
			Owner.SetAnimatorMoveSpeed();
		}

		public override void ExecutePerSecond()
		{
		}
	}
	public class HelperFarmerIdleState : StateBase<HelperCleanerStateMachine>
	{
		private HelperTaskFarm externalTask;

		private HelperCleaner Owner => base.stateMachine.Owner;

		public HelperFarmerIdleState(HelperCleanerStateMachine newStateMachine)
			: base(newStateMachine)
		{
		}

		public HelperFarmerIdleState(HelperCleanerStateMachine newStateMachine, HelperTaskFarm task)
			: base(newStateMachine)
		{
			externalTask = task;
		}

		public override void OnEnter()
		{
			if (externalTask != null)
			{
				base.stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerMoveToState(base.stateMachine, externalTask));
				return;
			}
			HelperTaskFarm helperTaskFarm = HelpersManager.Instance.GiveFarmerTask(Owner);
			if (helperTaskFarm != null)
			{
				base.stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerMoveToState(base.stateMachine, helperTaskFarm));
			}
			else
			{
				base.stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerMoveToDefaultPosState(base.stateMachine));
			}
		}

		public override void ExecutePerFrame()
		{
			Owner.SetAnimatorMoveSpeed();
		}

		public override void OnExit()
		{
		}

		public override void ExecutePerSecond()
		{
		}
	}
	public static class MyExt
	{
		public static HelperTaskFarm GiveFarmerTask(this HelpersManager target, HelperCleaner owner)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Invalid comparison between Unknown and I4
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			GardenManager instance = GardenManager.Instance;
			Item val = ((IEnumerable<Item>)StringExtension.ToList<Item>(((HelperBase)owner).containerRef.containerNet.items)).FirstOrDefault((Func<Item, bool>)Utils.IsHoe);
			bool flag = val.id != 0;
			bool flag2 = ((HelperBase)owner).containerRef.containerNet.GetItemAmount(Utils.FERTILIZER_ID) != 0;
			Item val2 = ((IEnumerable<Item>)StringExtension.ToList<Item>(((HelperBase)owner).containerRef.containerNet.items)).FirstOrDefault((Func<Item, bool>)((Item item) => item.dataId == Utils.WATER_CAN_ID && item.charge > 0));
			bool flag3 = val2.id != 0;
			if (!(flag || flag2 || flag3))
			{
				return null;
			}
			GardenBed[] gardenBeds = instance.gardenBeds;
			foreach (GardenBed val3 in gardenBeds)
			{
				bool flag4 = (int)val3.state.Value == 0;
				if (flag && flag4)
				{
					return new HelperTaskFarm(((Component)val3).transform.position, val3, HelperTaskFarm.TaskType.Farm, val);
				}
				if (flag3 && !flag4 && !val3.isWatered.Value)
				{
					return new HelperTaskFarm(((Component)val3).transform.position, val3, HelperTaskFarm.TaskType.Water, val2);
				}
				if (flag2 && !flag4 && !val3.isFertilized.Value)
				{
					return new HelperTaskFarm(((Component)val3).transform.position, val3, HelperTaskFarm.TaskType.Fertilize);
				}
			}
			return null;
		}
	}
	public class HelperFarmerMoveToDefaultPosState : StateBase<HelperCleanerStateMachine>
	{
		private HelperCleaner Owner => base.stateMachine.Owner;

		public HelperFarmerMoveToDefaultPosState(HelperCleanerStateMachine newStateMachine)
			: base(newStateMachine)
		{
		}

		public override void ExecutePerSecond()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (Owner.CanMove() && ((Behaviour)((HelperBase)Owner).agent).isActiveAndEnabled)
			{
				((HelperBase)Owner).agent.SetDestination(((HelperBase)Owner).defaultPos);
			}
			CheckOnNestSit();
		}

		private void CheckOnNestSit()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Vector3.Distance(((Component)Owner).transform.position, ((HelperBase)Owner).defaultPos) <= ((HelperBase)Owner).targetDetectDistance)
			{
				base.stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerNestSittingState(base.stateMachine));
			}
		}

		public override void ExecutePerFrame()
		{
			Owner.SetAnimatorMoveSpeed();
		}

		public override void OnEnter()
		{
			((StateBase<HelperCleanerStateMachine>)this).ExecutePerSecond();
		}

		public override void OnExit()
		{
		}
	}
	public class HelperFarmerMoveToState : StateBase<HelperCleanerStateMachine>
	{
		[CompilerGenerated]
		private sealed class <RecalculateAfterDelay>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HelperFarmerMoveToState <>4__this;

			private Vector3 <point>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RecalculateAfterDelay>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (HelpersManager.Instance.GetReachablePointOnNavMesh((HelperBase)(object)<>4__this.Owner, <>4__this.task.movePos, ref <point>5__1, 20f))
					{
						<>4__this.task.movePos = <point>5__1;
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private HelperTaskFarm task;

		private HelperCleaner Owner => base.stateMachine.Owner;

		public HelperFarmerMoveToState(HelperCleanerStateMachine newStateMachine, HelperTaskFarm newTask)
			: base(newStateMachine)
		{
			task = newTask;
		}

		private void OnFurniturePlaced()
		{
			((MonoBehaviour)Owner).StartCoroutine(RecalculateAfterDelay());
		}

		[IteratorStateMachine(typeof(<RecalculateAfterDelay>d__5))]
		private IEnumerator RecalculateAfterDelay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RecalculateAfterDelay>d__5(0)
			{
				<>4__this = this
			};
		}

		public override void ExecutePerFrame()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Owner.SetAnimatorMoveSpeed();
			if (Vector2.Distance(FlatDistanceExtension.xz(((Component)Owner).transform.position), FlatDistanceExtension.xz(task.movePos)) <= ((HelperBase)Owner).targetDetectDistance)
			{
				base.stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerFarmState(base.stateMachine, task));
			}
		}

		public override void ExecutePerSecond()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (Owner.CanMove())
			{
				((HelperBase)Owner).agent.SetDestination(task.movePos);
			}
		}

		private void OnDespawn()
		{
			FurnitureManager instance = FurnitureManager.Instance;
			instance.OnFurniturePlaced = (Action)Delegate.Remove(instance.OnFurniturePlaced, new Action(OnFurniturePlaced));
			HelperCleaner owner = Owner;
			owner.OnDespawn = (Action)Delegate.Remove(owner.OnDespawn, new Action(OnDespawn));
		}

		public override void OnEnter()
		{
			HelperCleaner owner = Owner;
			owner.OnDespawn = (Action)Delegate.Combine(owner.OnDespawn, new Action(OnDespawn));
			FurnitureManager instance = FurnitureManager.Instance;
			instance.OnFurniturePlaced = (Action)Delegate.Combine(instance.OnFurniturePlaced, new Action(OnFurniturePlaced));
		}

		public override void OnExit()
		{
			HelperCleaner owner = Owner;
			owner.OnDespawn = (Action)Delegate.Remove(owner.OnDespawn, new Action(OnDespawn));
			FurnitureManager instance = FurnitureManager.Instance;
			instance.OnFurniturePlaced = (Action)Delegate.Remove(instance.OnFurniturePlaced, new Action(OnFurniturePlaced));
		}
	}
	public class HelperFarmerNestSittingState : StateBase<HelperCleanerStateMachine>
	{
		[CompilerGenerated]
		private sealed class <JumpOff>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HelperFarmerNestSittingState <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <JumpOff>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Expected O, but got Unknown
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.jumpInvoked = true;
					<>4__this.DoJump(((HelperBase)<>4__this.Owner).landingPos.position);
					((HelperBase)<>4__this.Owner).animator.SetBool("NestSit", false);
					if (PlayerManager.Instance.isLocalPlayerSpawned)
					{
						SoundManager.Instance.PlayServerRpc((SoundEvent)8000, ((Component)<>4__this.Owner).transform.position, false, default(ServerRpcParams));
					}
					<>2__current = (object)new WaitForSeconds(<>4__this.jumpDuration);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Behaviour)((HelperBase)<>4__this.Owner).agent).enabled = true;
					((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerIdleState(((StateBase<HelperCleanerStateMachine>)<>4__this).stateMachine, <>4__this.task));
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private bool invokeJumpOnEnter;

		private bool jumpInvoked;

		private float jumpDuration = 1.2f;

		private HelperTaskFarm task;

		private HelperCleaner Owner => base.stateMachine.Owner;

		public HelperFarmerNestSittingState(HelperCleanerStateMachine newStateMachine, bool newInvokeJumpOnEnter = true)
			: base(newStateMachine)
		{
			invokeJumpOnEnter = newInvokeJumpOnEnter;
		}

		public override void OnEnter()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			((Behaviour)((HelperBase)Owner).agent).enabled = false;
			((HelperBase)Owner).animator.SetBool("NestSit", true);
			if (invokeJumpOnEnter)
			{
				DoJump(((HelperBase)Owner).defaultPos);
			}
			if (PlayerManager.Instance.isLocalPlayerSpawned)
			{
				SoundManager.Instance.PlayServerRpc((SoundEvent)8010, ((Component)Owner).transform.position, false, default(ServerRpcParams));
			}
		}

		public override void OnExit()
		{
		}

		[IteratorStateMachine(typeof(<JumpOff>d__9))]
		private IEnumerator JumpOff()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <JumpOff>d__9(0)
			{
				<>4__this = this
			};
		}

		private void DoJump(Vector3 endPos)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			((HelperBase)Owner).networkAnimator.SetTrigger("Jump");
			ShortcutExtensions.DOJump(((Component)Owner).transform, endPos, 1f, 1, jumpDuration, false);
			ShortcutExtensions.DORotate(((Component)Owner).transform, ((HelperBase)Owner).defaultRot, jumpDuration, (RotateMode)0);
		}

		public override void ExecutePerFrame()
		{
			Owner.SetAnimatorMoveSpeed();
		}

		public override void ExecutePerSecond()
		{
			if (!jumpInvoked && ((HelperBase)Owner).isActivated)
			{
				task = HelpersManager.Instance.GiveFarmerTask(Owner);
				if (task != null)
				{
					((MonoBehaviour)Owner).StartCoroutine(JumpOff());
				}
			}
		}
	}
	internal class HelperFarmerPatch
	{
		private static readonly List<Type> allowedTypes = new List<Type>(6)
		{
			typeof(HelperFarmerMoveToDefaultPosState),
			typeof(HelperFarmerFarmState),
			typeof(HelperFarmerNestSittingState),
			typeof(HelperFarmerMoveToState),
			typeof(HelperFarmerIdleState),
			typeof(HelperFarmerFullInventoryState)
		};

		[HarmonyPatch(typeof(HelperCleaner), "OnNetworkSpawn")]
		[HarmonyPostfix]
		[HarmonyDebug]
		public static void OnNetworkSpawn(HelperCleaner __instance)
		{
			if (((Object)((Component)__instance).gameObject).name == "Helper Farmer")
			{
				FieldInfo field = typeof(HelperCleaner).GetField("stateMachine", BindingFlags.Instance | BindingFlags.NonPublic);
				object? value = field.GetValue(__instance);
				HelperCleanerStateMachine val = (HelperCleanerStateMachine)((value is HelperCleanerStateMachine) ? value : null);
				val.SetInitState((StateBase<HelperCleanerStateMachine>)new HelperFarmerNestSittingState(val, newInvokeJumpOnEnter: false));
			}
		}

		[HarmonyPatch(typeof(HelperCleaner), "Activate")]
		[HarmonyPrefix]
		[HarmonyDebug]
		public static bool Activate(HelperCleaner __instance)
		{
			((HelperBase)__instance).isActivated = true;
			FieldInfo field = typeof(HelperCleaner).GetField("stateMachine", BindingFlags.Instance | BindingFlags.NonPublic);
			object? value = field.GetValue(__instance);
			HelperCleanerStateMachine val = (HelperCleanerStateMachine)((value is HelperCleanerStateMachine) ? value : null);
			if (((object)val.CurrentState).GetType().Name == "HelperFarmerMoveToDefaultPosState")
			{
				val.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerIdleState(val));
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(HelperCleaner), "Deactivate")]
		[HarmonyPrefix]
		[HarmonyDebug]
		public static bool Deactivate(HelperCleaner __instance)
		{
			FieldInfo field = typeof(HelperCleaner).GetField("stateMachine", BindingFlags.Instance | BindingFlags.NonPublic);
			object? value = field.GetValue(__instance);
			HelperCleanerStateMachine val = (HelperCleanerStateMachine)((value is HelperCleanerStateMachine) ? value : null);
			if (!allowedTypes.Contains(((object)val.CurrentState).GetType()))
			{
				return true;
			}
			val.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerMoveToDefaultPosState(val));
			HelpersManager.Instance.RemoveFromTaskList((HelperBase)(object)__instance);
			((HelperBase)__instance).isActivated = false;
			return false;
		}

		[HarmonyPatch(typeof(HelperCleaner), "CheckContainerChanged")]
		[HarmonyPrefix]
		[HarmonyDebug]
		public static bool CheckContainerChanged(HelperCleaner __instance)
		{
			FieldInfo field = typeof(HelperCleaner).GetField("stateMachine", BindingFlags.Instance | BindingFlags.NonPublic);
			object? value = field.GetValue(__instance);
			HelperCleanerStateMachine val = (HelperCleanerStateMachine)((value is HelperCleanerStateMachine) ? value : null);
			if (!allowedTypes.Contains(((object)val.CurrentState).GetType()))
			{
				return true;
			}
			if (val.CurrentState is HelperFarmerFullInventoryState && !((HelperBase)__instance).containerRef.containerNet.IsFull())
			{
				val.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerIdleState(val));
			}
			if (val.CurrentState is HelperFarmerMoveToState)
			{
				val.ChangeState((StateBase<HelperCleanerStateMachine>)new HelperFarmerIdleState(val));
			}
			return false;
		}
	}
	internal class HelperFarmerStateMachinePatch
	{
		[HarmonyPatch(typeof(HelperCleanerStateMachine), "ChangeState")]
		[HarmonyPrefix]
		[HarmonyDebug]
		private static bool ChangeState(HelperCleanerStateMachine __instance, StateBase<HelperCleanerStateMachine> newState)
		{
			if (((HelperBase)__instance.Owner).isActivated || !(((object)newState).GetType().Name != "HelperFarmerNestSittingState"))
			{
				__instance.Owner.currentStateName = ((object)newState).GetType().Name;
				FieldInfo field = typeof(HelperCleanerStateMachine).GetField("isTransition", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = typeof(HelperCleanerStateMachine).GetField("<PreviousState>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field3 = typeof(HelperCleanerStateMachine).GetField("<CurrentState>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
				field.SetValue(__instance, true);
				__instance.CurrentState.OnExit();
				field2.SetValue(__instance, __instance.CurrentState);
				field3.SetValue(__instance, newState);
				__instance.CurrentState.OnEnter();
				field.SetValue(__instance, false);
				return false;
			}
			return true;
		}
	}
	public class HelperTaskFarm : HelperTaskBase
	{
		public enum TaskType
		{
			Farm,
			Water,
			Fertilize
		}

		public Vector3 farmPos;

		public Vector3 movePos;

		public GardenBed gardenBed;

		public TaskType taskType;

		public Item item;

		public HelperTaskFarm(Vector3 newMovePos, GardenBed newGardenBed, TaskType newTaskType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			movePos = newMovePos;
			gardenBed = newGardenBed;
			taskType = newTaskType;
			((HelperTaskBase)this)..ctor();
		}

		public HelperTaskFarm(Vector3 newMovePos, GardenBed newGardenBed, TaskType newTaskType, Item newItem)
			: this(newMovePos, newGardenBed, newTaskType)
		{
			//IL_0001: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			item = newItem;
		}
	}
	[BepInPlugin("Sayrus.HelperFarmer", "Helper Farmer", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin Sayrus.HelperFarmer is loaded!");
			Harmony val = new Harmony("Sayrus.HelperFarmer");
			val.PatchAll(typeof(PatchGardenManager_Awake));
			val.PatchAll(typeof(HelperFarmerStateMachinePatch));
			val.PatchAll(typeof(HelperFarmerPatch));
			InjectLocalizedString("ItemData", "ItemDataNameHelperFarmerHouse", "Helper Farmer House");
			InjectLocalizedString("ItemData", "ItemDataDescrHelperFarmerHouse", "Helps with farming.");
			InjectLocalizedString("Interactive", "InteractiveNameHelperFarmer", "Helper Farmer");
		}

		private void InjectLocalizedString(string tableCollectionName, string key, string localizedValue)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			LocalizedStringDatabase stringDatabase = LocalizationSettings.StringDatabase;
			StringTable result = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)stringDatabase).GetTableAsync(TableReference.op_Implicit(tableCollectionName), (Locale)null).Result;
			if (!((Object)(object)result == (Object)null) && ((DetailedLocalizationTable<StringTableEntry>)(object)result).GetEntry(key) == null)
			{
				((DetailedLocalizationTable<StringTableEntry>)(object)result).AddEntry(key, localizedValue);
			}
		}
	}
	public class PatchGardenManager_Awake
	{
		private static ItemData savedItem;

		[HarmonyDebug]
		[HarmonyPatch(typeof(GardenManager), "Awake")]
		[HarmonyPrefix]
		private static void Prefix(GardenManager __instance)
		{
			if (!((Object)(object)GardenManager.Instance != (Object)null))
			{
				GardenBed[] gardenBeds = __instance.gardenBeds;
				foreach (GardenBed obj in gardenBeds)
				{
					typeof(GardenBed).GetField("targetHoeHitCount", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(obj, 1);
				}
			}
		}

		[HarmonyPatch(typeof(ItemManager), "Awake")]
		[HarmonyPrefix]
		[HarmonyDebug]
		private static void AddCustomItems(ItemManager __instance)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			ItemData val = __instance.itemDataHub.itemData.Where((ItemData item) => item.id == Utils.CLEANER_HOUSE_ID).First();
			ItemData val2 = new ItemData
			{
				id = Utils.FARMER_HOUSE_ID,
				name = "ItemDataNameHelperFarmerHouse",
				icon = val.icon,
				type = (Type)10,
				maxStack = 1,
				maxCharge = 0,
				durability = 0,
				durabilityPerHit = 0,
				durabilityDecreasePerRepair = 0,
				price = 1800,
				playerCantSell = false,
				playerCantDrop = false,
				buyByOne = false,
				quest = false,
				shopItem = true,
				alchemicalIngredient = false,
				commonLootItem = false,
				levelDependant = 3,
				questDependant = 0,
				doNotSave = false,
				collectiblePrefab = val.collectiblePrefab,
				fpPrefab = val.fpPrefab,
				tpPrefab = val.tpPrefab,
				netPrefab = val.netPrefab,
				containerClean = null,
				containerDirty = null,
				itemDescription = "ItemDataDescrHelperFarmerHouse"
			};
			__instance.itemDataHub.itemData = CollectionExtensions.AddItem<ItemData>((IEnumerable<ItemData>)__instance.itemDataHub.itemData, val2).ToArray();
			savedItem = val2;
			Debug.Log((object)"[AddCustomItems] Added custom wares");
		}

		[HarmonyPatch(typeof(FurnitureManager), "OnNetworkSpawn")]
		[HarmonyTranspiler]
		[HarmonyDebug]
		private static IEnumerable<CodeInstruction> Furniture_OnNetworkSpawn(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instruction) => instruction.opcode == OpCodes.Call && (instruction.operand as MethodInfo).Name == "Instantiate" && (instruction.operand as MethodInfo).ReturnType == typeof(GameObject)), (string)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_2, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SavedDevice), "itemDataId")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PatchGardenManager_Awake), "InstantiateFurniture_OnLoad", (Type[])null, (Type[])null))
			}).RemoveInstruction()
				.Instructions();
		}

		[HarmonyPatch(typeof(FurnitureManager), "PlaceFurnitureServerRpc", new Type[]
		{
			typeof(uint),
			typeof(Vector3),
			typeof(Quaternion),
			typeof(ServerRpcParams)
		})]
		[HarmonyTranspiler]
		[HarmonyDebug]
		private static IEnumerable<CodeInstruction> PlaceFurnitureServerRpc(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instruction) => instruction.opcode == OpCodes.Call && (instruction.operand as MethodInfo).Name == "Instantiate" && (instruction.operand as MethodInfo).ReturnType == typeof(GameObject)), (string)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_2, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Item), "dataId")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PatchGardenManager_Awake), "InstantiateFurniture", (Type[])null, (Type[])null))
			}).RemoveInstruction()
				.Instructions();
		}

		[HarmonyPatch(typeof(HelperHouse), "OnNetworkSpawn")]
		[HarmonyTranspiler]
		[HarmonyDebug]
		private static IEnumerable<CodeInstruction> OnNetworkSpawn(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instruction) => instruction.opcode == OpCodes.Call && (instruction.operand as MethodInfo).Name == "Instantiate" && (instruction.operand as MethodInfo).ReturnType == typeof(HelperBase)), (string)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(HelperHouse), "furniture")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PatchGardenManager_Awake), "InstantiateHelper", (Type[])null, (Type[])null))
			}).RemoveInstruction()
				.Instructions();
		}

		public static GameObject InstantiateFurniture_OnLoad(GameObject original, Vector3 position, Quaternion rotation, Transform parent, uint itemId)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(original, position, rotation, parent);
			if (itemId == Utils.FARMER_HOUSE_ID)
			{
				InitFarmerHouse(val);
			}
			return val;
		}

		public static GameObject InstantiateFurniture(GameObject original, Vector3 position, Quaternion rotation, uint itemId)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(original, position, rotation);
			if (itemId == Utils.FARMER_HOUSE_ID)
			{
				InitFarmerHouse(val);
			}
			return val;
		}

		private static void InitFarmerHouse(GameObject owlHouse)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)((Component)owlHouse.transform.Find("Container/Owls_Nest/Owls_Nest/Owls_Nest")).GetComponent<MeshRenderer>()).material.color = new Color(0.192f, 1f, 0.086f);
			ItemManager.Instance.GetItemData((uint)Utils.FARMER_HOUSE_ID, ref owlHouse.GetComponent<Furniture>().itemData);
		}

		public static Object InstantiateHelper(Object original, Vector3 position, Quaternion rotation, Furniture demo)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			Object obj = Object.Instantiate(original, position, rotation);
			HelperBase val = (HelperBase)(object)((obj is HelperBase) ? obj : null);
			if (demo.itemData.id == Utils.FARMER_HOUSE_ID)
			{
				((Renderer)((Component)((Component)val).transform.Find("HalloweenOwl_Gr/coat_low")).GetComponent<SkinnedMeshRenderer>()).material.color = new Color(0.192f, 1f, 0.086f);
				((Renderer)((Component)((Component)val).transform.Find("HalloweenOwl_Gr/hood_low")).GetComponent<SkinnedMeshRenderer>()).material.color = new Color(0.192f, 1f, 0.086f);
				((Object)val).name = "Helper Farmer";
				((Component)val).GetComponent<Interactive>().ObjectTitle = "InteractiveNameHelperFarmer";
			}
			return (Object)(object)val;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Sayrus.HelperFarmer";

		public const string PLUGIN_NAME = "Helper Farmer";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}