using System;
using System.Collections;
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 BepInEx;
using BepInEx.Logging;
using EasyTextEffects.Editor.MyBoxCopy.Extensions;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LoveCompany")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LoveCompany")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("24200df4-b26b-4577-8900-6d6e22e77868")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[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 LoveCompany
{
	public class CoupleSync : NetworkBehaviour
	{
		public struct CoupleData : INetworkSerializable
		{
			public FixedString64Bytes A;

			public FixedString64Bytes B;

			public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
			{
				//IL_000a: 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)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				((BufferSerializer<FixedString64Bytes>*)(&serializer))->SerializeValue<FixedString64Bytes>(ref A, default(ForFixedStrings));
				((BufferSerializer<FixedString64Bytes>*)(&serializer))->SerializeValue<FixedString64Bytes>(ref B, default(ForFixedStrings));
			}
		}

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

			private object <>2__current;

			public CoupleSync <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_0058: 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_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				CoupleSync coupleSync = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					Debug.Log((object)$"CoupleA: {Couple.Value.A} CoupleB: {Couple.Value.B}");
					CoupleData value = Couple.Value;
					ref FixedString64Bytes a = ref value.A;
					FixedString32Bytes val = FixedString32Bytes.op_Implicit("");
					if (!((ref a) == (ref val)))
					{
						CoupleData value2 = Couple.Value;
						ref FixedString64Bytes b = ref value2.B;
						FixedString32Bytes val2 = FixedString32Bytes.op_Implicit("");
						if (!((ref b) == (ref val2)))
						{
							Debug.Log((object)"[CoupleSync] Waiting to Applying Color and Showing Couple");
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
					}
					return false;
				}
				case 2:
					<>1__state = -1;
					coupleSync.ApplyColor();
					coupleSync.ShowCouple();
					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 <DelayedResetCouple>d__25 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CoupleSync <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				CoupleSync coupleSync = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)NetworkManager.Singleton == (Object)null || (!NetworkManager.Singleton.IsServer && !NetworkManager.Singleton.IsHost))
					{
						return false;
					}
					if ((Object)(object)Instance == (Object)null)
					{
						return false;
					}
					coupleSync.ServerResetCouple();
					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 <DelayedSetCouple>d__23 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RoundManager __instance;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: 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(7f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if ((Object)(object)Instance == (Object)null || !((NetworkBehaviour)Instance).IsSpawned)
					{
						Plugin.mls.LogError((object)"CoupleSync not spawned yet");
						return false;
					}
					PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
					if (((Object)__instance.currentLevel).name == "CompanyBuildingLevel")
					{
						Plugin.mls.LogInfo((object)"No Couple in Company Building!");
						return false;
					}
					try
					{
						List<string> list = new List<string>();
						for (int i = 0; i < allPlayerScripts.Count(); i++)
						{
							if (allPlayerScripts[i].playerSteamId != 0L && allPlayerScripts[i].isPlayerControlled && !allPlayerScripts[i].isPlayerDead)
							{
								list.Add(allPlayerScripts[i].playerUsername);
							}
						}
						Plugin.mls.LogInfo((object)$"Players Count : {list.Count()}");
						if (list.Count() < 2)
						{
							Plugin.mls.LogWarning((object)"Not enough players to be matched!");
							return false;
						}
						int index = Random.Range(0, list.Count);
						string text = list[index];
						list.RemoveAt(index);
						Plugin.mls.LogInfo((object)("coupleA : " + text));
						index = Random.Range(0, list.Count);
						string text2 = list[index];
						Plugin.mls.LogInfo((object)("coupleB : " + text2));
						Couple.Value = new CoupleData
						{
							A = FixedString64Bytes.op_Implicit(text),
							B = FixedString64Bytes.op_Implicit(text2)
						};
					}
					catch (Exception arg)
					{
						Plugin.mls.LogError((object)$"An Error Occured while setting Couple! {arg}");
					}
					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 static readonly LNetworkMessage<string> KillCoupleMessage = LNetworkMessage<string>.Connect("KillCoupleMessage", (Action<string, ulong>)null, (Action<string>)null, (Action<string, ulong>)null);

		public static readonly LNetworkEvent ResetCoupleEvent = LNetworkEvent.Connect("ResetCoupleEvent", (Action<ulong>)null, (Action)null, (Action<ulong>)null);

		public static readonly LNetworkVariable<CoupleData> Couple = LNetworkVariable<CoupleData>.Connect("Couple", default(CoupleData), (LNetworkVariableWritePerms)0, (Action<CoupleData, CoupleData>)null);

		private Coroutine applyRoutine;

		private bool tipShown;

		public static CoupleSync Instance { get; private set; }

		public override void OnNetworkSpawn()
		{
			Debug.Log((object)$"[CoupleSync] OnNetworkSpawn (IsServer={((NetworkBehaviour)this).IsServer}, IsClient={((NetworkBehaviour)this).IsClient}) Instance={this}");
			((NetworkBehaviour)this).OnNetworkSpawn();
			Instance = this;
			KillCoupleMessage.OnServerReceived += ServerReceivedKillCoupleMessage;
			KillCoupleMessage.OnClientReceived += ClientReceivedKillCoupleMessage;
			ResetCoupleEvent.OnClientReceived += ClientReceivedResetCoupleEvent;
			Couple.OnValueChanged += OnCoupleChanged;
		}

		public override void OnNetworkDespawn()
		{
			Debug.Log((object)"[CoupleSync] OnNetworkDespawn");
			((NetworkBehaviour)this).OnNetworkDespawn();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			if (applyRoutine != null)
			{
				TryStopCoroutine(applyRoutine);
				applyRoutine = null;
			}
			KillCoupleMessage.OnServerReceived -= ServerReceivedKillCoupleMessage;
			KillCoupleMessage.OnClientReceived -= ClientReceivedKillCoupleMessage;
			ResetCoupleEvent.OnClientReceived -= ClientReceivedResetCoupleEvent;
			Couple.OnValueChanged -= OnCoupleChanged;
		}

		private void TryStopCoroutine(Coroutine c)
		{
			try
			{
				((MonoBehaviour)this).StopCoroutine(c);
			}
			catch
			{
			}
		}

		private void OnCoupleChanged(CoupleData oldval, CoupleData newval)
		{
			Debug.Log((object)$"[CoupleSync] OnCoupleChanged called IsClient={((NetworkBehaviour)this).IsClient} old={oldval} new={newval}");
			if (applyRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(applyRoutine);
			}
			applyRoutine = ((MonoBehaviour)this).StartCoroutine(DelayedApply());
		}

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

		private void ServerReceivedKillCoupleMessage(string killed, ulong senderClient)
		{
			KillCouple(killed);
		}

		public void KillCouple(string killed)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			Plugin.mls.LogInfo((object)"[KillCouple] Killing Couple");
			CoupleData value = Couple.Value;
			ref FixedString64Bytes a = ref value.A;
			FixedString32Bytes val = FixedString32Bytes.op_Implicit("");
			if (!((ref a) == (ref val)))
			{
				CoupleData value2 = Couple.Value;
				ref FixedString64Bytes b = ref value2.B;
				FixedString32Bytes val2 = FixedString32Bytes.op_Implicit("");
				if (!((ref b) == (ref val2)))
				{
					KillCoupleMessage.SendClients(killed);
					Plugin.mls.LogInfo((object)"[KillCouple] Resetting Couple");
					((MonoBehaviour)this).StartCoroutine(DelayedResetCouple());
				}
			}
		}

		private void ClientReceivedKillCoupleMessage(string killed)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			CoupleData value = Couple.Value;
			string text = ((object)(FixedString64Bytes)(ref value.A)).ToString();
			value = Couple.Value;
			string text2 = ((object)(FixedString64Bytes)(ref value.B)).ToString();
			if (!(killed != text) || !(killed != text2))
			{
				string text3 = ((killed == text) ? text2 : text);
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				if (localPlayerController.playerUsername == text3)
				{
					localPlayerController.DamagePlayer(999, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
				}
			}
		}

		private void ServerResetCouple()
		{
			//IL_0038: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				if (applyRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(applyRoutine);
					applyRoutine = null;
				}
				Couple.Value = new CoupleData
				{
					A = FixedString64Bytes.op_Implicit(""),
					B = FixedString64Bytes.op_Implicit("")
				};
				ResetCoupleEvent.InvokeClients();
			}
		}

		private void ClientReceivedResetCoupleEvent()
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			for (int i = 0; i < allPlayerScripts.Count(); i++)
			{
				PlayerControllerB val = allPlayerScripts[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.usernameBillboardText == (Object)null))
				{
					((TMP_Text)val.usernameBillboardText).text = val.playerUsername;
				}
			}
		}

		private void ShowCouple()
		{
			//IL_0029: 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)
			if (!tipShown)
			{
				tipShown = true;
				HUDManager.Instance.DisplayTip("Congratulations!", $"{Couple.Value.A} " + $"and {Couple.Value.B} fell in love.", false, false, "LC_Tip1");
			}
		}

		private void ApplyColor()
		{
			CoupleData value = Couple.Value;
			string text = ((object)(FixedString64Bytes)(ref value.A)).ToString();
			value = Couple.Value;
			string text2 = ((object)(FixedString64Bytes)(ref value.B)).ToString();
			if (MyString.IsNullOrEmpty(text) || MyString.IsNullOrEmpty(text2))
			{
				return;
			}
			string playerUsername = GameNetworkManager.Instance.localPlayerController.playerUsername;
			if (MyString.IsNullOrEmpty(playerUsername) || (!(playerUsername == text) && !(playerUsername == text2)))
			{
				return;
			}
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			if (allPlayerScripts == null || allPlayerScripts.Length == 0)
			{
				return;
			}
			for (int i = 0; i < allPlayerScripts.Count(); i++)
			{
				PlayerControllerB val = allPlayerScripts[i];
				if (!((Object)(object)val == (Object)null) && !MyString.IsNullOrEmpty(val.playerUsername) && !((Object)(object)val.usernameBillboardText == (Object)null))
				{
					string playerUsername2 = val.playerUsername;
					if ((playerUsername == text && playerUsername2 == text2) || (playerUsername == text2 && playerUsername2 == text))
					{
						((TMP_Text)val.usernameBillboardText).text = "<color=#ff46dc>" + val.playerUsername + "</color>";
					}
					else
					{
						((TMP_Text)val.usernameBillboardText).text = val.playerUsername;
					}
				}
			}
		}

		public void StartDelayedSetCouple(RoundManager __instance)
		{
			if (((NetworkBehaviour)this).IsServer && !((Object)(object)__instance == (Object)null))
			{
				((MonoBehaviour)this).StartCoroutine(DelayedSetCouple(__instance));
			}
		}

		[IteratorStateMachine(typeof(<DelayedSetCouple>d__23))]
		private IEnumerator DelayedSetCouple(RoundManager __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedSetCouple>d__23(0)
			{
				__instance = __instance
			};
		}

		public void StartDelayedResetCouple()
		{
			tipShown = false;
			((MonoBehaviour)this).StartCoroutine(DelayedResetCouple());
		}

		[IteratorStateMachine(typeof(<DelayedResetCouple>d__25))]
		private IEnumerator DelayedResetCouple()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedResetCouple>d__25(0)
			{
				<>4__this = this
			};
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("choguin.lovecompany", "LoveCompany", "0.1.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string modGUID = "choguin.lovecompany";

		public const string modName = "LoveCompany";

		public const string modVersion = "0.1.1";

		private Harmony _harmony = new Harmony("choguin.lovecompany");

		internal static ManualLogSource mls = Logger.CreateLogSource(" LoveCompany");

		public static AssetBundle LoveCompanyAssets;

		private void Awake()
		{
			mls.LogInfo((object)"LoveCompany Awaked");
			_harmony.PatchAll();
			string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			string text = Path.Combine(directoryName, "lovecompany");
			LoveCompanyAssets = AssetBundle.LoadFromFile(text);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LoveCompany";

		public const string PLUGIN_NAME = "LoveCompany";

		public const string PLUGIN_VERSION = "0.0.1";
	}
}
namespace LoveCompany.Patches
{
	[HarmonyPatch]
	public class NetworkObjectManager
	{
		private static GameObject coupleSyncObject;

		private static bool prefabRegistered;

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPostfix]
		public static void Init()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (!prefabRegistered && !((Object)(object)coupleSyncObject != (Object)null))
			{
				coupleSyncObject = (GameObject)Plugin.LoveCompanyAssets.LoadAsset("CoupleSyncObject");
				coupleSyncObject.AddComponent<CoupleSync>();
				NetworkManager.Singleton.AddNetworkPrefab(coupleSyncObject);
				prefabRegistered = true;
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPostfix]
		private static void SpawnCoupleSync()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(coupleSyncObject, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(false);
			}
		}
	}
	[HarmonyPatch]
	internal class Patch
	{
		private static string coupleA;

		private static string coupleB;

		[HarmonyPatch(typeof(RoundManager), "FinishGeneratingLevel")]
		[HarmonyPostfix]
		private static void SetCouplePatch(RoundManager __instance)
		{
			if (NetworkManager.Singleton.IsServer)
			{
				if ((Object)(object)CoupleSync.Instance == (Object)null || !((NetworkBehaviour)CoupleSync.Instance).IsSpawned)
				{
					Plugin.mls.LogError((object)"CoupleSync not ready, cannot start coroutine");
				}
				else
				{
					CoupleSync.Instance.StartDelayedSetCouple(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		[HarmonyPostfix]
		private static void KillCouplePatch(PlayerControllerB __instance)
		{
			if (!((Object)(object)CoupleSync.Instance == (Object)null))
			{
				Plugin.mls.LogInfo((object)("[KillCouplePatch] " + __instance.playerUsername));
				if (NetworkManager.Singleton.IsServer)
				{
					CoupleSync.Instance.KillCouple(__instance.playerUsername);
				}
				else
				{
					CoupleSync.KillCoupleMessage.SendServer(__instance.playerUsername);
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
		[HarmonyPostfix]
		private static void ResetCouplePatch(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer)
			{
				if ((Object)(object)CoupleSync.Instance == (Object)null || !((NetworkBehaviour)CoupleSync.Instance).IsSpawned)
				{
					Plugin.mls.LogError((object)"CoupleSync not ready, cannot start coroutine");
				}
				else
				{
					CoupleSync.Instance.StartDelayedResetCouple();
				}
			}
		}
	}
}