using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ItemShareFix.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ItemShareFix.Core")]
[assembly: AssemblyTitle("ItemShareFix.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ItemShareFix.Core
{
	public static class BlockingModalLifecyclePolicy
	{
		public const string PauseScreenControllerTypeName = "RoR2.UI.PauseScreenController";

		public const string SimpleDialogBoxTypeName = "RoR2.UI.SimpleDialogBox";

		public const string PickupPickerPanelTypeName = "RoR2.UI.PickupPickerPanel";

		public static bool IsKnownBlockingModalTypeName(string? typeName)
		{
			if (!(typeName == "RoR2.UI.PauseScreenController") && !(typeName == "RoR2.UI.SimpleDialogBox"))
			{
				return typeName == "RoR2.UI.PickupPickerPanel";
			}
			return true;
		}

		public static bool ShouldSeedObservedCandidate(bool knownBlockingType, bool sceneObjectValid)
		{
			return knownBlockingType && sceneObjectValid;
		}

		public static bool ShouldAddObservedInstance(bool instanceAlreadyCached)
		{
			return !instanceAlreadyCached;
		}

		public static bool LifecycleSeedRequiresGlobalDiscovery(bool observedCandidateCached)
		{
			return !observedCandidateCached;
		}

		public static bool SuppressionStateChanged(bool previousSuppressed, bool currentSuppressed)
		{
			return previousSuppressed != currentSuppressed;
		}

		public static bool PreserveRareFallbackCadence(float fallbackSeconds)
		{
			return fallbackSeconds >= 5f;
		}
	}
	public sealed class ClaimLedger
	{
		private readonly Dictionary<ClaimKey, ClaimRecord> _records = new Dictionary<ClaimKey, ClaimRecord>();

		private readonly Dictionary<HistoricalClaimKey, HistoricalClaimRecord> _history = new Dictionary<HistoricalClaimKey, HistoricalClaimRecord>();

		public IReadOnlyCollection<ClaimRecord> Records => _records.Values;

		public IReadOnlyCollection<HistoricalClaimRecord> HistoricalRecords => _history.Values;

		public ClaimRecord Ensure(SharedPickupKey pickup, ParticipantKey participant, ParticipantState state, int stage)
		{
			if (!TryEnsure(pickup, participant, state, stage, out ClaimRecord record))
			{
				throw new InvalidOperationException("Historical pickup barrier rejected participant generation: " + pickup.ToString() + "/" + participant);
			}
			return record;
		}

		public bool TryEnsure(SharedPickupKey pickup, ParticipantKey participant, ParticipantState state, int stage, out ClaimRecord record)
		{
			ClaimKey key = new ClaimKey(pickup, participant);
			if (_records.TryGetValue(key, out ClaimRecord value))
			{
				record = value;
				return true;
			}
			if (IsHistoricallyBlocked(pickup, participant.StableUser))
			{
				record = null;
				return false;
			}
			ClaimState claimState = ((state == ParticipantState.FullyDead) ? ClaimState.Deferred : ClaimState.Pending);
			if (state == ParticipantState.Disconnected)
			{
				claimState = ClaimState.CancelledDisconnected;
			}
			ClaimRecord claimRecord = new ClaimRecord(key, claimState, stage);
			if (claimState == ClaimState.CancelledDisconnected)
			{
				claimRecord.TerminalStage = stage;
				SetHistory(pickup, participant.StableUser, HistoricalClaimState.CancelledDisconnected, stage);
			}
			_records.Add(key, claimRecord);
			record = claimRecord;
			return true;
		}

		public bool TryGet(SharedPickupKey pickup, ParticipantKey participant, out ClaimRecord record)
		{
			return _records.TryGetValue(new ClaimKey(pickup, participant), out record);
		}

		public bool IsHistoricallyBlocked(SharedPickupKey pickup, StableUserKey stableUser)
		{
			return _history.ContainsKey(new HistoricalClaimKey(pickup, stableUser));
		}

		public bool TryGetHistorical(SharedPickupKey pickup, StableUserKey stableUser, out HistoricalClaimRecord record)
		{
			return _history.TryGetValue(new HistoricalClaimKey(pickup, stableUser), out record);
		}

		public IReadOnlyList<HistoricalClaimRecord> HistoricalFor(StableUserKey stableUser)
		{
			return (from x in _history.Values
				where x.Key.StableUser.Equals(stableUser)
				orderby x.Key.Pickup.Value
				select x).ToArray();
		}

		public bool MarkCollected(SharedPickupKey pickup, ParticipantKey participant, int stage)
		{
			if (!TryGet(pickup, participant, out ClaimRecord record))
			{
				return false;
			}
			if (record.State != ClaimState.Pending)
			{
				return false;
			}
			record.State = ClaimState.Collected;
			record.TerminalStage = stage;
			SetHistory(pickup, participant.StableUser, HistoricalClaimState.Collected, stage);
			return true;
		}

		public int TransitionParticipant(ParticipantKey participant, ParticipantState from, ParticipantState to, int stage)
		{
			int num = 0;
			ClaimRecord[] array = _records.Values.Where((ClaimRecord x) => x.Key.Participant.Equals(participant)).ToArray();
			foreach (ClaimRecord claimRecord in array)
			{
				switch (to)
				{
				case ParticipantState.Disconnected:
					if (claimRecord.State == ClaimState.Pending || claimRecord.State == ClaimState.Deferred)
					{
						claimRecord.State = ClaimState.CancelledDisconnected;
						claimRecord.TerminalStage = stage;
						SetHistory(claimRecord.Key.Pickup, participant.StableUser, HistoricalClaimState.CancelledDisconnected, stage);
						num++;
					}
					break;
				case ParticipantState.FullyDead:
					if (claimRecord.State == ClaimState.Pending)
					{
						claimRecord.State = ClaimState.Deferred;
						num++;
					}
					break;
				}
			}
			return num;
		}

		public bool MarkDeferredGranted(ClaimKey key, int stage)
		{
			if (!_records.TryGetValue(key, out ClaimRecord value))
			{
				return false;
			}
			if (value.State != ClaimState.Deferred)
			{
				return false;
			}
			value.State = ClaimState.GrantedDeferred;
			value.TerminalStage = stage;
			SetHistory(value.Key.Pickup, value.Key.Participant.StableUser, HistoricalClaimState.GrantedDeferred, stage);
			return true;
		}

		public IReadOnlyList<ClaimRecord> DeferredFor(ParticipantKey participant, int beforeStage)
		{
			return (from x in _records.Values
				where x.Key.Participant.Equals(participant) && x.State == ClaimState.Deferred && x.CreatedStage < beforeStage
				orderby x.CreatedStage, x.Key.Pickup.Value
				select x).ToArray();
		}

		public int TransferPickup(SharedPickupKey oldPickup, SharedPickupKey newPickup)
		{
			if (oldPickup.Equals(newPickup))
			{
				return 0;
			}
			ClaimRecord[] array = _records.Values.Where((ClaimRecord x) => x.Key.Pickup.Equals(oldPickup)).ToArray();
			HistoricalClaimRecord[] array2 = _history.Values.Where((HistoricalClaimRecord x) => x.Key.Pickup.Equals(oldPickup)).ToArray();
			ClaimRecord[] array3 = array;
			foreach (ClaimRecord claimRecord in array3)
			{
				ClaimKey key = new ClaimKey(newPickup, claimRecord.Key.Participant);
				if (_records.ContainsKey(key))
				{
					throw new InvalidOperationException("Transfer would create duplicate pickup/participant state: " + key);
				}
			}
			HistoricalClaimRecord[] array4 = array2;
			foreach (HistoricalClaimRecord historicalClaimRecord in array4)
			{
				HistoricalClaimKey key2 = new HistoricalClaimKey(newPickup, historicalClaimRecord.Key.StableUser);
				if (_history.TryGetValue(key2, out HistoricalClaimRecord value) && value.State != historicalClaimRecord.State)
				{
					throw new InvalidOperationException("Transfer would create conflicting historical pickup/stable-user state: " + key2);
				}
			}
			array3 = array;
			foreach (ClaimRecord claimRecord2 in array3)
			{
				ClaimKey key3 = claimRecord2.Key;
				ClaimKey key4 = new ClaimKey(newPickup, key3.Participant);
				_records.Remove(key3);
				claimRecord2.Key = key4;
				_records.Add(key4, claimRecord2);
			}
			array4 = array2;
			foreach (HistoricalClaimRecord historicalClaimRecord2 in array4)
			{
				HistoricalClaimKey key5 = historicalClaimRecord2.Key;
				HistoricalClaimKey key6 = new HistoricalClaimKey(newPickup, key5.StableUser);
				_history.Remove(key5);
				if (_history.TryGetValue(key6, out HistoricalClaimRecord value2))
				{
					if (historicalClaimRecord2.Stage > value2.Stage)
					{
						value2.Stage = historicalClaimRecord2.Stage;
					}
				}
				else
				{
					historicalClaimRecord2.Key = key6;
					_history.Add(key6, historicalClaimRecord2);
				}
			}
			return array.Length;
		}

		public int OnStageTransition(int newStage)
		{
			int num = 0;
			KeyValuePair<ClaimKey, ClaimRecord>[] array = _records.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ClaimKey, ClaimRecord> keyValuePair = array[i];
				ClaimState state = keyValuePair.Value.State;
				if (state == ClaimState.Pending || state == ClaimState.Collected || state == ClaimState.CancelledDisconnected || state == ClaimState.GrantedDeferred)
				{
					_records.Remove(keyValuePair.Key);
					num++;
				}
			}
			_history.Clear();
			return num;
		}

		public int Clear()
		{
			int result = _records.Count + _history.Count;
			_records.Clear();
			_history.Clear();
			return result;
		}

		public int RemoveTerminalOlderThan(int stageExclusive)
		{
			int num = 0;
			KeyValuePair<ClaimKey, ClaimRecord>[] array = _records.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ClaimKey, ClaimRecord> keyValuePair = array[i];
				int? terminalStage = keyValuePair.Value.TerminalStage;
				if (terminalStage.HasValue && terminalStage.Value < stageExclusive)
				{
					_records.Remove(keyValuePair.Key);
					num++;
				}
			}
			KeyValuePair<HistoricalClaimKey, HistoricalClaimRecord>[] array2 = _history.ToArray();
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<HistoricalClaimKey, HistoricalClaimRecord> keyValuePair2 = array2[i];
				if (keyValuePair2.Value.Stage < stageExclusive)
				{
					_history.Remove(keyValuePair2.Key);
					num++;
				}
			}
			return num;
		}

		private void SetHistory(SharedPickupKey pickup, StableUserKey stableUser, HistoricalClaimState state, int stage)
		{
			HistoricalClaimKey key = new HistoricalClaimKey(pickup, stableUser);
			if (_history.TryGetValue(key, out HistoricalClaimRecord value))
			{
				if (value.State != state)
				{
					if (value.State == HistoricalClaimState.Collected || value.State == HistoricalClaimState.GrantedDeferred)
					{
						return;
					}
					value.State = state;
				}
				if (stage > value.Stage)
				{
					value.Stage = stage;
				}
			}
			else
			{
				_history.Add(key, new HistoricalClaimRecord(key, state, stage));
			}
		}
	}
	public enum CommandOptionPickupSource
	{
		None,
		NestedPickup,
		DirectCompatibilityFallback
	}
	public readonly struct CommandOptionPickupDecision<T>
	{
		public bool HasValue { get; }

		public T Value { get; }

		public CommandOptionPickupSource Source { get; }

		public bool ExactSource { get; }

		public bool Disagreement { get; }

		public CommandOptionPickupDecision(bool hasValue, T value, CommandOptionPickupSource source, bool exactSource, bool disagreement)
		{
			HasValue = hasValue;
			Value = value;
			Source = source;
			ExactSource = exactSource;
			Disagreement = disagreement;
		}
	}
	public static class CommandOptionSourcePolicy
	{
		public const string AuthoritativeSourceToken = "nested-pickup";

		public const string FallbackSourceToken = "direct-fallback";

		public const string UnresolvedSourceToken = "unresolved";

		public static CommandOptionPickupDecision<T> Resolve<T>(bool nestedAvailable, T nestedValue, bool directAvailable, T directValue)
		{
			if (nestedAvailable)
			{
				bool disagreement = directAvailable && !EqualityComparer<T>.Default.Equals(nestedValue, directValue);
				return new CommandOptionPickupDecision<T>(hasValue: true, nestedValue, CommandOptionPickupSource.NestedPickup, exactSource: true, disagreement);
			}
			if (directAvailable)
			{
				return new CommandOptionPickupDecision<T>(hasValue: true, directValue, CommandOptionPickupSource.DirectCompatibilityFallback, exactSource: false, disagreement: false);
			}
			return new CommandOptionPickupDecision<T>(hasValue: false, default(T), CommandOptionPickupSource.None, exactSource: false, disagreement: false);
		}

		public static string SourceToken(CommandOptionPickupSource source)
		{
			return source switch
			{
				CommandOptionPickupSource.NestedPickup => "nested-pickup", 
				CommandOptionPickupSource.DirectCompatibilityFallback => "direct-fallback", 
				_ => "unresolved", 
			};
		}
	}
	public enum CommandShareabilityState
	{
		Unresolved,
		AllShareable,
		AllUnshareable,
		Mixed
	}
	public readonly struct CommandShareabilityDecision
	{
		public CommandShareabilityState State { get; }

		public bool MarkerEligible => State == CommandShareabilityState.AllShareable;

		public string DiagnosticToken => State switch
		{
			CommandShareabilityState.AllShareable => "all-shareable", 
			CommandShareabilityState.AllUnshareable => "all-unshareable", 
			CommandShareabilityState.Mixed => "mixed", 
			_ => "unresolved", 
		};

		public string FilterReason => State switch
		{
			CommandShareabilityState.AllUnshareable => "upstream-not-shareable", 
			CommandShareabilityState.Mixed => "mixed-shareability", 
			CommandShareabilityState.Unresolved => "shareability-unresolved", 
			_ => string.Empty, 
		};

		public CommandShareabilityDecision(CommandShareabilityState state)
		{
			State = state;
		}
	}
	public static class CommandShareabilityPolicy
	{
		public static CommandShareabilityDecision Evaluate(IEnumerable<bool?>? optionShareability)
		{
			if (optionShareability == null)
			{
				return new CommandShareabilityDecision(CommandShareabilityState.Unresolved);
			}
			bool?[] array = optionShareability.ToArray();
			if (array.Length == 0 || array.Any((bool? x) => !x.HasValue))
			{
				return new CommandShareabilityDecision(CommandShareabilityState.Unresolved);
			}
			bool flag = array.Any((bool? x) => x == true);
			bool flag2 = array.Any((bool? x) => x == false);
			if (flag && flag2)
			{
				return new CommandShareabilityDecision(CommandShareabilityState.Mixed);
			}
			if (flag)
			{
				return new CommandShareabilityDecision(CommandShareabilityState.AllShareable);
			}
			return new CommandShareabilityDecision(CommandShareabilityState.AllUnshareable);
		}
	}
	public enum NetworkDestroyDisposition
	{
		IgnoreStillAuthoritative,
		HoldForAuthoritativeConfirmation
	}
	public static class DisconnectConfirmationPolicy
	{
		public static bool AllowsImmediateCancelFromNetworkDestroy => false;

		public static bool UsesObjectNamePrefabOrBodyHeuristics => false;

		public static NetworkDestroyDisposition EvaluateNetworkDestroy(bool participantResolved, bool authoritativePresence)
		{
			if (!(participantResolved && authoritativePresence))
			{
				return NetworkDestroyDisposition.HoldForAuthoritativeConfirmation;
			}
			return NetworkDestroyDisposition.IgnoreStillAuthoritative;
		}

		public static bool ShouldConfirmDisconnect(bool participantAbsentFromAuthoritativeControllerList, bool absenceGraceElapsed)
		{
			return participantAbsentFromAuthoritativeControllerList && absenceGraceElapsed;
		}
	}
	public enum GenerationProbeState
	{
		NeverResolved,
		Resolved,
		Frozen
	}
	public enum UnsupportedProbeDisposition
	{
		NoOwnershipEstablished,
		FreezePreserveExistingState
	}
	public sealed class GenerationProbeGate
	{
		private ParticipantKey? _provenParticipant;

		public GenerationProbeState State { get; private set; }

		public bool HasProvenParticipant => _provenParticipant.HasValue;

		public ParticipantKey ProvenParticipant => _provenParticipant ?? throw new InvalidOperationException("No proven participant exists for this generation.");

		public bool CanCreateClaims => State == GenerationProbeState.Resolved;

		public bool CanUseHistoricalBarrier => HasProvenParticipant;

		public bool CanGrantDeferred(ParticipantState exactState)
		{
			if (State == GenerationProbeState.Resolved)
			{
				return exactState == ParticipantState.Alive;
			}
			return false;
		}

		public bool TryResolve(ParticipantKey participant)
		{
			if (_provenParticipant.HasValue && !_provenParticipant.Value.Equals(participant))
			{
				return false;
			}
			_provenParticipant = participant;
			State = GenerationProbeState.Resolved;
			return true;
		}

		public UnsupportedProbeDisposition ObserveUnsupported()
		{
			if (!_provenParticipant.HasValue)
			{
				State = GenerationProbeState.NeverResolved;
				return UnsupportedProbeDisposition.NoOwnershipEstablished;
			}
			State = GenerationProbeState.Frozen;
			return UnsupportedProbeDisposition.FreezePreserveExistingState;
		}
	}
	public enum ImmediateGiveDecision
	{
		AllowUpstream,
		SuppressHistoricalBarrier,
		SuppressFullyDeadDeferred,
		SuppressExistingDeferredEntitlement
	}
	public static class ImmediateGivePolicy
	{
		public static ImmediateGiveDecision Decide(bool stableIdentityResolved, ParticipantState? participantState, bool deadPlayerDeferredItemsEnabled, bool historicalBarrierForCurrentPickup, bool deferredEntitlementReadyForCurrentPickup = false)
		{
			if (!stableIdentityResolved)
			{
				return ImmediateGiveDecision.AllowUpstream;
			}
			if (historicalBarrierForCurrentPickup)
			{
				return ImmediateGiveDecision.SuppressHistoricalBarrier;
			}
			if (deferredEntitlementReadyForCurrentPickup)
			{
				if (participantState.HasValue && participantState.Value == ParticipantState.FullyDead && deadPlayerDeferredItemsEnabled)
				{
					return ImmediateGiveDecision.SuppressFullyDeadDeferred;
				}
				return ImmediateGiveDecision.SuppressExistingDeferredEntitlement;
			}
			return ImmediateGiveDecision.AllowUpstream;
		}

		public static bool ShouldSuppress(bool stableIdentityResolved, ParticipantState? participantState, bool deadPlayerDeferredItemsEnabled, bool historicalBarrierForCurrentPickup, bool deferredEntitlementReadyForCurrentPickup = false)
		{
			return Decide(stableIdentityResolved, participantState, deadPlayerDeferredItemsEnabled, historicalBarrierForCurrentPickup, deferredEntitlementReadyForCurrentPickup) != ImmediateGiveDecision.AllowUpstream;
		}
	}
	public static class ItemShareActiveGatePolicy
	{
		public static bool ShouldCorrectIsDown(bool upstreamOriginalIsDown, bool authoritativeControllerPresent, bool exactGenerationProven, ParticipantState participantState)
		{
			if (upstreamOriginalIsDown && authoritativeControllerPresent && exactGenerationProven)
			{
				return participantState == ParticipantState.SupportDrone;
			}
			return false;
		}

		public static bool CorrectIsDown(bool upstreamOriginalIsDown, bool authoritativeControllerPresent, bool exactGenerationProven, ParticipantState participantState)
		{
			if (!ShouldCorrectIsDown(upstreamOriginalIsDown, authoritativeControllerPresent, exactGenerationProven, participantState))
			{
				return upstreamOriginalIsDown;
			}
			return false;
		}

		public static bool CountsAsOutstandingCollector(bool authoritativeControllerPresent, ParticipantState participantState)
		{
			if (authoritativeControllerPresent)
			{
				if (participantState != ParticipantState.Alive)
				{
					return participantState == ParticipantState.SupportDrone;
				}
				return true;
			}
			return false;
		}

		public static bool IsDeadAutoShareTarget(bool upstreamOriginalIsDown, bool authoritativeControllerPresent, bool exactGenerationProven, ParticipantState participantState)
		{
			return CorrectIsDown(upstreamOriginalIsDown, authoritativeControllerPresent, exactGenerationProven, participantState);
		}
	}
	public readonly struct LocalCommandPresentationDecision
	{
		public bool AllLocalStateResolved { get; }

		public bool AnyLocalPending { get; }

		public bool SuppressWorldPresentation { get; }

		public LocalCommandPresentationDecision(bool allLocalStateResolved, bool anyLocalPending, bool suppressWorldPresentation)
		{
			AllLocalStateResolved = allLocalStateResolved;
			AnyLocalPending = anyLocalPending;
			SuppressWorldPresentation = suppressWorldPresentation;
		}
	}
	public static class LocalCommandPresentationPolicy
	{
		public static LocalCommandPresentationDecision Evaluate(IReadOnlyList<bool?> localPickedStates)
		{
			if (localPickedStates == null)
			{
				throw new ArgumentNullException("localPickedStates");
			}
			if (localPickedStates.Count == 0)
			{
				return new LocalCommandPresentationDecision(allLocalStateResolved: false, anyLocalPending: false, suppressWorldPresentation: false);
			}
			bool flag = true;
			bool flag2 = false;
			for (int i = 0; i < localPickedStates.Count; i++)
			{
				bool? flag3 = localPickedStates[i];
				if (!flag3.HasValue)
				{
					flag = false;
				}
				else if (!flag3.Value)
				{
					flag2 = true;
				}
			}
			bool suppressWorldPresentation = flag && !flag2;
			return new LocalCommandPresentationDecision(flag, flag2, suppressWorldPresentation);
		}
	}
	public static class LocalParticipantPresentationPolicy
	{
		public static ParticipantState Classify(bool masterAvailable, bool exactRemoteOperationSignal, bool bodyPresent)
		{
			if (!masterAvailable)
			{
				return ParticipantState.Disconnected;
			}
			if (exactRemoteOperationSignal)
			{
				return ParticipantState.SupportDrone;
			}
			if (bodyPresent)
			{
				return ParticipantState.Alive;
			}
			return ParticipantState.FullyDead;
		}
	}
	public static class LocalPickupSuppressionPolicy
	{
		public static bool AllowsAuthoritativePickupDestroy => false;

		public static bool AllowsSharedRootDisable => false;

		public static bool AllowsSharedColliderDisable => false;

		public static bool ShouldSuppressProcessVisual(bool featureEnabled, bool upstreamHideCollectedEnabled, int localParticipantCount, int collectedLocalParticipantCount)
		{
			if (featureEnabled && upstreamHideCollectedEnabled && localParticipantCount > 0)
			{
				return collectedLocalParticipantCount == localParticipantCount;
			}
			return false;
		}

		public static bool ShouldSuppressInteractor(bool featureEnabled, bool upstreamHideCollectedEnabled, bool shareablePickup, bool interactorIsLocal, bool interactorHasCollected)
		{
			return featureEnabled && upstreamHideCollectedEnabled && shareablePickup && interactorIsLocal && interactorHasCollected;
		}
	}
	public readonly struct MarkerExpansionCandidate
	{
		public long ClusterKey { get; }

		public int MemberCount { get; }

		public float DistanceMeters { get; }

		public float ReticleDistancePixels1080 { get; }

		public MarkerExpansionCandidate(long clusterKey, int memberCount, float distanceMeters, float reticleDistancePixels1080)
		{
			ClusterKey = clusterKey;
			MemberCount = Math.Max(0, memberCount);
			DistanceMeters = distanceMeters;
			ReticleDistancePixels1080 = reticleDistancePixels1080;
		}
	}
	public sealed class MarkerAdaptiveLodTracker
	{
		public const int DenseClusterMinimumMembers = 3;

		public const float FocusEnterPixels1080 = 72f;

		public const float FocusExitPixels1080 = 110f;

		public const float NearEnterMeters = 18f;

		public const float NearExitMeters = 22f;

		public const float UniqueNearestMarginMeters = 1f;

		public const double FocusAcquireDwellSeconds = 0.12;

		public const double NearAcquireDwellSeconds = 0.25;

		public const double ReleaseDwellSeconds = 0.2;

		private long? _expandedKey;

		private long? _pendingKey;

		private double _pendingSince;

		private bool _pendingRelease;

		public long? ExpandedKey => _expandedKey;

		public long? Update(IReadOnlyList<MarkerExpansionCandidate> candidates, double nowSeconds)
		{
			if (candidates == null)
			{
				throw new ArgumentNullException("candidates");
			}
			if (double.IsNaN(nowSeconds) || double.IsInfinity(nowSeconds))
			{
				nowSeconds = 0.0;
			}
			if (_expandedKey.HasValue && IsCurrentStillQualified(candidates, _expandedKey.Value))
			{
				long? num = FindFocused(candidates, useExitForCurrent: true);
				if (!num.HasValue || num.Value == _expandedKey.Value)
				{
					ResetPending();
					return _expandedKey;
				}
			}
			long? num2 = FindFocused(candidates, useExitForCurrent: false);
			if (num2.HasValue)
			{
				return AdvanceToward(num2.Value, nowSeconds, 0.12);
			}
			long? num3 = FindUniqueNearest(candidates);
			if (num3.HasValue)
			{
				return AdvanceToward(num3.Value, nowSeconds, 0.25);
			}
			if (!_expandedKey.HasValue)
			{
				ResetPending();
				return null;
			}
			if (!_pendingRelease)
			{
				_pendingRelease = true;
				_pendingKey = null;
				_pendingSince = nowSeconds;
				return _expandedKey;
			}
			if (nowSeconds - _pendingSince < 0.2)
			{
				return _expandedKey;
			}
			_expandedKey = null;
			ResetPending();
			return null;
		}

		public void Clear()
		{
			_expandedKey = null;
			ResetPending();
		}

		private long? AdvanceToward(long desiredKey, double nowSeconds, double dwellSeconds)
		{
			_pendingRelease = false;
			if (_expandedKey.HasValue && _expandedKey.Value == desiredKey)
			{
				ResetPending();
				return _expandedKey;
			}
			if (!_pendingKey.HasValue || _pendingKey.Value != desiredKey)
			{
				_pendingKey = desiredKey;
				_pendingSince = nowSeconds;
				return _expandedKey;
			}
			if (nowSeconds - _pendingSince < dwellSeconds)
			{
				return _expandedKey;
			}
			_expandedKey = desiredKey;
			ResetPending();
			return _expandedKey;
		}

		private bool IsCurrentStillQualified(IReadOnlyList<MarkerExpansionCandidate> candidates, long key)
		{
			for (int i = 0; i < candidates.Count; i++)
			{
				MarkerExpansionCandidate markerExpansionCandidate = candidates[i];
				if (markerExpansionCandidate.ClusterKey == key && markerExpansionCandidate.MemberCount >= 3)
				{
					if (!(markerExpansionCandidate.ReticleDistancePixels1080 <= 110f))
					{
						return markerExpansionCandidate.DistanceMeters <= 22f;
					}
					return true;
				}
			}
			return false;
		}

		private long? FindFocused(IReadOnlyList<MarkerExpansionCandidate> candidates, bool useExitForCurrent)
		{
			float num = (useExitForCurrent ? 110f : 72f);
			bool flag = false;
			MarkerExpansionCandidate markerExpansionCandidate = default(MarkerExpansionCandidate);
			for (int i = 0; i < candidates.Count; i++)
			{
				MarkerExpansionCandidate markerExpansionCandidate2 = candidates[i];
				if (markerExpansionCandidate2.MemberCount >= 3 && IsFiniteNonNegative(markerExpansionCandidate2.ReticleDistancePixels1080) && !(markerExpansionCandidate2.ReticleDistancePixels1080 > num) && (!flag || markerExpansionCandidate2.ReticleDistancePixels1080 < markerExpansionCandidate.ReticleDistancePixels1080 || (Math.Abs(markerExpansionCandidate2.ReticleDistancePixels1080 - markerExpansionCandidate.ReticleDistancePixels1080) <= 0.001f && (markerExpansionCandidate2.DistanceMeters < markerExpansionCandidate.DistanceMeters || (Math.Abs(markerExpansionCandidate2.DistanceMeters - markerExpansionCandidate.DistanceMeters) <= 0.001f && markerExpansionCandidate2.ClusterKey < markerExpansionCandidate.ClusterKey)))))
				{
					flag = true;
					markerExpansionCandidate = markerExpansionCandidate2;
				}
			}
			if (!flag)
			{
				return null;
			}
			return markerExpansionCandidate.ClusterKey;
		}

		private static long? FindUniqueNearest(IReadOnlyList<MarkerExpansionCandidate> candidates)
		{
			bool flag = false;
			MarkerExpansionCandidate markerExpansionCandidate = default(MarkerExpansionCandidate);
			float num = float.PositiveInfinity;
			for (int i = 0; i < candidates.Count; i++)
			{
				MarkerExpansionCandidate markerExpansionCandidate2 = candidates[i];
				if (markerExpansionCandidate2.MemberCount < 3 || !IsFiniteNonNegative(markerExpansionCandidate2.DistanceMeters) || markerExpansionCandidate2.DistanceMeters > 18f)
				{
					continue;
				}
				if (!flag || markerExpansionCandidate2.DistanceMeters < markerExpansionCandidate.DistanceMeters || (Math.Abs(markerExpansionCandidate2.DistanceMeters - markerExpansionCandidate.DistanceMeters) <= 0.001f && markerExpansionCandidate2.ClusterKey < markerExpansionCandidate.ClusterKey))
				{
					if (flag)
					{
						num = markerExpansionCandidate.DistanceMeters;
					}
					markerExpansionCandidate = markerExpansionCandidate2;
					flag = true;
				}
				else if (markerExpansionCandidate2.DistanceMeters < num)
				{
					num = markerExpansionCandidate2.DistanceMeters;
				}
			}
			if (!flag)
			{
				return null;
			}
			if (!float.IsPositiveInfinity(num) && num - markerExpansionCandidate.DistanceMeters < 1f)
			{
				return null;
			}
			return markerExpansionCandidate.ClusterKey;
		}

		private void ResetPending()
		{
			_pendingKey = null;
			_pendingRelease = false;
			_pendingSince = 0.0;
		}

		private static bool IsFiniteNonNegative(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return value >= 0f;
			}
			return false;
		}
	}
	public enum MarkerCategorySortOrder
	{
		HighToLow,
		LowToHigh
	}
	public readonly struct MarkerCompactLayoutSlot
	{
		public int Row { get; }

		public int Column { get; }

		public int RowSize { get; }

		public float XUnits { get; }

		public float YUnits { get; }

		public MarkerCompactLayoutSlot(int row, int column, int rowSize, float xUnits, float yUnits)
		{
			Row = row;
			Column = column;
			RowSize = rowSize;
			XUnits = xUnits;
			YUnits = yUnits;
		}
	}
	public readonly struct MarkerCompactCellGeometry
	{
		public float BadgeSize { get; }

		public float CountWidth { get; }

		public float CountGap { get; }

		public float CellWidth { get; }

		public float HorizontalStride { get; }

		public float VerticalStride { get; }

		public MarkerCompactCellGeometry(float badgeSize, float countWidth, float countGap, float cellWidth, float horizontalStride, float verticalStride)
		{
			BadgeSize = badgeSize;
			CountWidth = countWidth;
			CountGap = countGap;
			CellWidth = cellWidth;
			HorizontalStride = horizontalStride;
			VerticalStride = verticalStride;
		}
	}
	public static class MarkerCategorySummaryPolicy
	{
		public const MarkerCategorySortOrder DefaultSortOrder = MarkerCategorySortOrder.HighToLow;

		public const float PyramidMaxVerticalOffsetUnits = 0.6f;

		public const float PyramidMinimumHorizontalSpacingFactor = 0.62f;

		public const int MaxCategories = 11;

		public static int DisplayPriority(MarkerSemanticCategory category)
		{
			return category switch
			{
				MarkerSemanticCategory.Tier3 => 110, 
				MarkerSemanticCategory.Boss => 100, 
				MarkerSemanticCategory.Lunar => 90, 
				MarkerSemanticCategory.Void => 80, 
				MarkerSemanticCategory.Tier2 => 70, 
				MarkerSemanticCategory.Equipment => 60, 
				MarkerSemanticCategory.LunarEquipment => 50, 
				MarkerSemanticCategory.Tier1 => 40, 
				MarkerSemanticCategory.CommandState => 30, 
				MarkerSemanticCategory.Other => 20, 
				_ => 10, 
			};
		}

		public static MarkerCompactCategoryBadge[] BuildCategoryEntries(IReadOnlyList<MarkerCategoryCount> composition, MarkerCategorySortOrder sortOrder)
		{
			if (composition == null)
			{
				throw new ArgumentNullException("composition");
			}
			int num = 0;
			for (int i = 0; i < composition.Count; i++)
			{
				if (num >= 11)
				{
					break;
				}
				if (composition[i].Count > 0)
				{
					num++;
				}
			}
			MarkerCompactCategoryBadge[] array = new MarkerCompactCategoryBadge[num];
			int num2 = 0;
			for (int j = 0; j < composition.Count; j++)
			{
				if (num2 >= array.Length)
				{
					break;
				}
				MarkerCategoryCount markerCategoryCount = composition[j];
				if (markerCategoryCount.Count > 0)
				{
					array[num2++] = new MarkerCompactCategoryBadge(markerCategoryCount.Category, markerCategoryCount.Count, DisplayPriority(markerCategoryCount.Category));
				}
			}
			for (int k = 1; k < array.Length; k++)
			{
				MarkerCompactCategoryBadge markerCompactCategoryBadge = array[k];
				int num3 = k - 1;
				while (num3 >= 0 && Compare(markerCompactCategoryBadge, array[num3], sortOrder) < 0)
				{
					array[num3 + 1] = array[num3];
					num3--;
				}
				array[num3 + 1] = markerCompactCategoryBadge;
			}
			return array;
		}

		public static float PyramidVerticalOffsetUnits(MarkerSemanticCategory category)
		{
			float num = ((float)DisplayPriority(category) - 10f) / 100f;
			if (num < 0f)
			{
				num = 0f;
			}
			if (num > 1f)
			{
				num = 1f;
			}
			return num * 0.6f;
		}

		public static float PyramidHorizontalSpacingFactor(int categoryCount)
		{
			if (categoryCount <= 3)
			{
				return 1f;
			}
			float num = 1f - (float)(categoryCount - 3) * 0.055f;
			if (!(num < 0.62f))
			{
				return num;
			}
			return 0.62f;
		}

		public static float BuildCategoryGlyphSize(float screenWidth, float screenHeight, float markerScale, float indicatorSize, float fontSize)
		{
			float num = (IsFinitePositive(screenWidth) ? screenWidth : 1920f);
			float num2 = (IsFinitePositive(screenHeight) ? screenHeight : 1080f);
			float num3 = (IsFinitePositive(markerScale) ? markerScale : 1f);
			if (num3 < 0.75f)
			{
				num3 = 0.75f;
			}
			if (num3 > 1.25f)
			{
				num3 = 1.25f;
			}
			float num4 = Math.Min(num / 1920f, num2 / 1080f);
			if (!IsFinitePositive(num4))
			{
				num4 = 1f;
			}
			float num5 = num4 * num3;
			float num6 = (IsFinitePositive(indicatorSize) ? indicatorSize : (24f * num5));
			float num7 = (IsFinitePositive(fontSize) ? fontSize : (20f * num5));
			return Math.Max(12f * num5, Math.Min(num6 * 0.58f, num7 * 0.78f));
		}

		public static float BuildCompactLifetimeGroupGap(float screenWidth, float screenHeight, float markerScale, float indicatorSize, float fontSize)
		{
			float num = (IsFinitePositive(screenWidth) ? screenWidth : 1920f);
			float num2 = (IsFinitePositive(screenHeight) ? screenHeight : 1080f);
			float num3 = (IsFinitePositive(markerScale) ? markerScale : 1f);
			if (num3 < 0.75f)
			{
				num3 = 0.75f;
			}
			if (num3 > 1.25f)
			{
				num3 = 1.25f;
			}
			float num4 = Math.Min(num / 1920f, num2 / 1080f);
			if (!IsFinitePositive(num4))
			{
				num4 = 1f;
			}
			float num5 = num4 * num3;
			float indicatorSize2 = (IsFinitePositive(indicatorSize) ? indicatorSize : (24f * num5));
			float fontSize2 = (IsFinitePositive(fontSize) ? fontSize : (20f * num5));
			float num6 = BuildCategoryGlyphSize(num, num2, num3, indicatorSize2, fontSize2);
			return Math.Max(4f * num5, num6 * 0.18f);
		}

		public static float BuildCompactCategoryCenterHorizontalStride(float screenWidth, float screenHeight, float markerScale, float indicatorSize, float fontSize, int categoryCount)
		{
			float num = (IsFinitePositive(screenWidth) ? screenWidth : 1920f);
			float num2 = (IsFinitePositive(screenHeight) ? screenHeight : 1080f);
			float num3 = (IsFinitePositive(markerScale) ? markerScale : 1f);
			if (num3 < 0.75f)
			{
				num3 = 0.75f;
			}
			if (num3 > 1.25f)
			{
				num3 = 1.25f;
			}
			float num4 = Math.Min(num / 1920f, num2 / 1080f);
			if (!IsFinitePositive(num4))
			{
				num4 = 1f;
			}
			float num5 = num4 * num3;
			float indicatorSize2 = (IsFinitePositive(indicatorSize) ? indicatorSize : (24f * num5));
			float fontSize2 = (IsFinitePositive(fontSize) ? fontSize : (20f * num5));
			MarkerCompactCellGeometry markerCompactCellGeometry = BuildCompactCellGeometry(num, num2, num3, indicatorSize2, fontSize2, showCount: false);
			float num6 = BuildCompactLifetimeGroupGap(num, num2, num3, indicatorSize2, fontSize2);
			float num7 = Math.Max(4f * num5, markerCompactCellGeometry.BadgeSize * 0.18f);
			float num8 = markerCompactCellGeometry.HorizontalStride * PyramidHorizontalSpacingFactor(categoryCount);
			MarkerCompactLayoutSlot[] array = BuildCompactLayout(categoryCount);
			bool flag = false;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].RowSize >= 3)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return num8;
			}
			float val = markerCompactCellGeometry.BadgeSize * 1.5f + num6 * 0.5f + num7;
			return Math.Max(num8, val);
		}

		public static float BuildCompactCategoryCenterVerticalStride(float screenWidth, float screenHeight, float markerScale, float indicatorSize, float fontSize)
		{
			return BuildCompactCellGeometry(screenWidth, screenHeight, markerScale, indicatorSize, fontSize, showCount: false).VerticalStride;
		}

		public static float BuildDetailedCategoryDistanceGap(float screenWidth, float screenHeight, float markerScale, float indicatorSize, float fontSize)
		{
			float num = (IsFinitePositive(screenWidth) ? screenWidth : 1920f);
			float num2 = (IsFinitePositive(screenHeight) ? screenHeight : 1080f);
			float num3 = (IsFinitePositive(markerScale) ? markerScale : 1f);
			if (num3 < 0.75f)
			{
				num3 = 0.75f;
			}
			if (num3 > 1.25f)
			{
				num3 = 1.25f;
			}
			float num4 = Math.Min(num / 1920f, num2 / 1080f);
			if (!IsFinitePositive(num4))
			{
				num4 = 1f;
			}
			float num5 = num4 * num3;
			float indicatorSize2 = (IsFinitePositive(indicatorSize) ? indicatorSize : (24f * num5));
			float num6 = (IsFinitePositive(fontSize) ? fontSize : (20f * num5));
			float num7 = BuildCategoryGlyphSize(num, num2, num3, indicatorSize2, num6);
			float num8 = num6 * 1.18f;
			float num9 = Math.Max(num8, num7 + 2f * num5);
			return Math.Max(0f, num9 - (num7 + num8) * 0.5f);
		}

		public static float BuildCompactLifetimeGroupOffsetX(MarkerCompactLayoutSlot categorySlot, int groupOrdinal, int groupCount, float glyphSize, float lifetimeGroupGap)
		{
			int num = Math.Max(1, groupCount);
			int num2 = Math.Max(0, Math.Min(num - 1, groupOrdinal));
			if (num == 1)
			{
				return 0f;
			}
			float num3 = (IsFinitePositive(glyphSize) ? glyphSize : 1f);
			float num4 = ((!float.IsNaN(lifetimeGroupGap) && !float.IsInfinity(lifetimeGroupGap) && lifetimeGroupGap > 0f) ? lifetimeGroupGap : 0f);
			float num5 = num3 + num4;
			float num6 = (float)(Math.Max(1, categorySlot.RowSize) - 1) * 0.5f;
			if (categorySlot.RowSize > 1 && (float)categorySlot.Column < num6)
			{
				return (float)(-num2) * num5;
			}
			if (categorySlot.RowSize > 1 && (float)categorySlot.Column > num6)
			{
				return (float)num2 * num5;
			}
			return ((float)num2 - (float)(num - 1) * 0.5f) * num5;
		}

		public static MarkerCompactCellGeometry BuildCompactCellGeometry(float screenWidth, float screenHeight, float markerScale, float indicatorSize, float fontSize, bool showCount)
		{
			float num = (IsFinitePositive(screenWidth) ? screenWidth : 1920f);
			float num2 = (IsFinitePositive(screenHeight) ? screenHeight : 1080f);
			float num3 = (IsFinitePositive(markerScale) ? markerScale : 1f);
			if (num3 < 0.75f)
			{
				num3 = 0.75f;
			}
			if (num3 > 1.25f)
			{
				num3 = 1.25f;
			}
			float num4 = Math.Min(num / 1920f, num2 / 1080f);
			if (!IsFinitePositive(num4))
			{
				num4 = 1f;
			}
			float num5 = num4 * num3;
			float indicatorSize2 = (IsFinitePositive(indicatorSize) ? indicatorSize : (24f * num5));
			float num6 = (IsFinitePositive(fontSize) ? fontSize : (20f * num5));
			float num7 = BuildCategoryGlyphSize(num, num2, num3, indicatorSize2, num6);
			float num8 = (showCount ? Math.Max(24f * num5, num6 * 2.2f) : 0f);
			float num9 = (showCount ? Math.Max(5f * num5, num6 * 0.18f) : 0f);
			float num10 = num7 + num9 + num8;
			float num11 = Math.Max(10f * num5, num7 * 0.28f);
			float horizontalStride = num10 + num11;
			float verticalStride = Math.Max(num7 + 10f * num5, num6 * 1.45f);
			return new MarkerCompactCellGeometry(num7, num8, num9, num10, horizontalStride, verticalStride);
		}

		private static bool IsFinitePositive(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return value > 0f;
			}
			return false;
		}

		public static MarkerCompactLayoutSlot[] BuildCompactLayout(int categoryCount)
		{
			int num = Math.Max(0, Math.Min(11, categoryCount));
			if (num == 0)
			{
				return Array.Empty<MarkerCompactLayoutSlot>();
			}
			int[] array = CompactRowPattern(num);
			MarkerCompactLayoutSlot[] array2 = new MarkerCompactLayoutSlot[num];
			int num2 = 0;
			int num3 = array.Length;
			for (int i = 0; i < array.Length; i++)
			{
				int num4 = array[i];
				float yUnits = (float)(num3 - 1) * 0.5f - (float)i;
				for (int j = 0; j < num4; j++)
				{
					if (num2 >= num)
					{
						break;
					}
					float xUnits = (float)j - (float)(num4 - 1) * 0.5f;
					array2[num2++] = new MarkerCompactLayoutSlot(i, j, num4, xUnits, yUnits);
				}
			}
			return array2;
		}

		private static int[] CompactRowPattern(int count)
		{
			return count switch
			{
				1 => new int[1] { 1 }, 
				2 => new int[2] { 1, 1 }, 
				3 => new int[2] { 1, 2 }, 
				4 => new int[3] { 1, 2, 1 }, 
				5 => new int[3] { 1, 3, 1 }, 
				6 => new int[4] { 1, 2, 2, 1 }, 
				7 => new int[4] { 1, 2, 3, 1 }, 
				8 => new int[5] { 1, 2, 2, 2, 1 }, 
				9 => new int[5] { 1, 2, 3, 2, 1 }, 
				10 => new int[5] { 1, 2, 3, 3, 1 }, 
				_ => new int[5] { 1, 3, 3, 3, 1 }, 
			};
		}

		private static int Compare(MarkerCompactCategoryBadge left, MarkerCompactCategoryBadge right, MarkerCategorySortOrder sortOrder)
		{
			int num = right.DisplayPriority.CompareTo(left.DisplayPriority);
			if (sortOrder == MarkerCategorySortOrder.LowToHigh)
			{
				num = -num;
			}
			if (num != 0)
			{
				return num;
			}
			int num2 = MarkerSemanticCategoryPolicy.StableOrder(left.Category).CompareTo(MarkerSemanticCategoryPolicy.StableOrder(right.Category));
			if (sortOrder != MarkerCategorySortOrder.LowToHigh)
			{
				return num2;
			}
			return -num2;
		}
	}
	public enum MarkerClassKind
	{
		Unknown,
		Tier1,
		Tier2,
		Tier3,
		Boss,
		Lunar,
		Void,
		Equipment,
		LunarEquipment,
		Other
	}
	public readonly struct CommandClassPresentation
	{
		public MarkerClassKind Kind { get; }

		public string Label { get; }

		public bool ExactClass { get; }

		public CommandClassPresentation(MarkerClassKind kind, string label, bool exactClass)
		{
			Kind = kind;
			Label = (string.IsNullOrWhiteSpace(label) ? "Item choice" : label);
			ExactClass = exactClass;
		}
	}
	public static class MarkerClassPolicy
	{
		public static bool UsesCatalogPickupBaseColor => true;

		public static bool UsesArtifactCommandName => false;

		public static string CommandChoiceSource => "PickupPickerController.options/PickupIndex";

		public static string AuthoritativeCommandChoiceSource => "PickupPickerController.options/option.pickup.pickupIndex";

		public static MarkerClassKind Classify(string? itemTierName, bool isEquipment, bool isLunarEquipment)
		{
			if (isEquipment)
			{
				if (!isLunarEquipment)
				{
					return MarkerClassKind.Equipment;
				}
				return MarkerClassKind.LunarEquipment;
			}
			string text = itemTierName ?? string.Empty;
			if (string.Equals(text, "Tier1", StringComparison.Ordinal))
			{
				return MarkerClassKind.Tier1;
			}
			if (string.Equals(text, "Tier2", StringComparison.Ordinal))
			{
				return MarkerClassKind.Tier2;
			}
			if (string.Equals(text, "Tier3", StringComparison.Ordinal))
			{
				return MarkerClassKind.Tier3;
			}
			if (string.Equals(text, "Boss", StringComparison.Ordinal))
			{
				return MarkerClassKind.Boss;
			}
			if (string.Equals(text, "Lunar", StringComparison.Ordinal))
			{
				return MarkerClassKind.Lunar;
			}
			if (text.StartsWith("Void", StringComparison.Ordinal))
			{
				return MarkerClassKind.Void;
			}
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, "NoTier", StringComparison.Ordinal))
			{
				return MarkerClassKind.Unknown;
			}
			return MarkerClassKind.Other;
		}

		public static string DiagnosticClassName(MarkerClassKind kind)
		{
			return kind switch
			{
				MarkerClassKind.Tier1 => "WHITE", 
				MarkerClassKind.Tier2 => "GREEN", 
				MarkerClassKind.Tier3 => "RED", 
				MarkerClassKind.Boss => "YELLOW", 
				MarkerClassKind.Lunar => "LUNAR_BLUE", 
				MarkerClassKind.Void => "VOID_PURPLE", 
				MarkerClassKind.Equipment => "EQUIPMENT", 
				MarkerClassKind.LunarEquipment => "LUNAR_EQUIPMENT", 
				MarkerClassKind.Other => "OTHER", 
				_ => "UNKNOWN", 
			};
		}

		public static string LocalizedClassLabel(MarkerClassKind kind, bool russian)
		{
			if (russian)
			{
				return kind switch
				{
					MarkerClassKind.Tier1 => "Белый", 
					MarkerClassKind.Tier2 => "Зелёный", 
					MarkerClassKind.Tier3 => "Красный", 
					MarkerClassKind.Boss => "Жёлтый", 
					MarkerClassKind.Lunar => "Синий", 
					MarkerClassKind.Void => "Фиолетовый", 
					MarkerClassKind.Equipment => "Снаряжение", 
					MarkerClassKind.LunarEquipment => "Лунное снаряжение", 
					_ => "Выбор предмета", 
				};
			}
			return kind switch
			{
				MarkerClassKind.Tier1 => "White", 
				MarkerClassKind.Tier2 => "Green", 
				MarkerClassKind.Tier3 => "Red", 
				MarkerClassKind.Boss => "Yellow", 
				MarkerClassKind.Lunar => "Blue", 
				MarkerClassKind.Void => "Purple", 
				MarkerClassKind.Equipment => "Equipment", 
				MarkerClassKind.LunarEquipment => "Lunar equipment", 
				_ => "Item choice", 
			};
		}

		public static CommandClassPresentation ResolveCommandClass(IEnumerable<MarkerClassKind>? choiceClasses, bool russian)
		{
			if (choiceClasses == null)
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedClassLabel(MarkerClassKind.Unknown, russian), exactClass: false);
			}
			MarkerClassKind[] array = choiceClasses.ToArray();
			if (array.Length == 0 || array.Any((MarkerClassKind x) => x == MarkerClassKind.Unknown))
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedClassLabel(MarkerClassKind.Unknown, russian), exactClass: false);
			}
			MarkerClassKind[] array2 = array.Distinct().ToArray();
			if (array2.Length != 1)
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedClassLabel(MarkerClassKind.Unknown, russian), exactClass: false);
			}
			MarkerClassKind markerClassKind = array2[0];
			if (markerClassKind == MarkerClassKind.Other)
			{
				return new CommandClassPresentation(MarkerClassKind.Other, LocalizedClassLabel(MarkerClassKind.Other, russian), exactClass: false);
			}
			return new CommandClassPresentation(markerClassKind, LocalizedClassLabel(markerClassKind, russian), exactClass: true);
		}

		public static string LocalizedSemanticClassLabel(MarkerClassKind kind, bool russian)
		{
			if (russian)
			{
				return kind switch
				{
					MarkerClassKind.Tier1 => "Белый", 
					MarkerClassKind.Tier2 => "Зелёный", 
					MarkerClassKind.Tier3 => "Красный", 
					MarkerClassKind.Boss => "Жёлтый", 
					MarkerClassKind.Lunar => "Лунный", 
					MarkerClassKind.Void => "Предмет Бездны", 
					MarkerClassKind.Equipment => "Снаряжение", 
					MarkerClassKind.LunarEquipment => "Лунное снаряжение", 
					_ => "Выбор предмета", 
				};
			}
			return kind switch
			{
				MarkerClassKind.Tier1 => "White", 
				MarkerClassKind.Tier2 => "Green", 
				MarkerClassKind.Tier3 => "Red", 
				MarkerClassKind.Boss => "Yellow", 
				MarkerClassKind.Lunar => "Lunar", 
				MarkerClassKind.Void => "Void", 
				MarkerClassKind.Equipment => "Equipment", 
				MarkerClassKind.LunarEquipment => "Lunar equipment", 
				_ => "Item choice", 
			};
		}

		public static CommandClassPresentation ResolveCommandClassForPresentation(IEnumerable<MarkerClassKind>? choiceClasses, bool russian)
		{
			if (choiceClasses == null)
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedSemanticClassLabel(MarkerClassKind.Unknown, russian), exactClass: false);
			}
			MarkerClassKind[] array = choiceClasses.ToArray();
			if (array.Length == 0 || array.Any((MarkerClassKind x) => x == MarkerClassKind.Unknown))
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedSemanticClassLabel(MarkerClassKind.Unknown, russian), exactClass: false);
			}
			MarkerClassKind[] array2 = array.Distinct().ToArray();
			if (array2.Length != 1)
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedSemanticClassLabel(MarkerClassKind.Unknown, russian), exactClass: false);
			}
			MarkerClassKind markerClassKind = array2[0];
			if (markerClassKind == MarkerClassKind.Other)
			{
				return new CommandClassPresentation(MarkerClassKind.Other, LocalizedSemanticClassLabel(MarkerClassKind.Other, russian), exactClass: false);
			}
			return new CommandClassPresentation(markerClassKind, LocalizedSemanticClassLabel(markerClassKind, russian), exactClass: true);
		}

		public static string LocalizedReadableClassLabel(MarkerClassKind kind, bool russian)
		{
			return LocalizedReadableClassLabel(kind, MarkerTextLocalization.FromRussianCompatibility(russian));
		}

		public static string LocalizedReadableClassLabel(MarkerClassKind kind, MarkerLanguage language)
		{
			return MarkerTextLocalization.ReadableClassLabel(kind, language);
		}

		public static CommandClassPresentation ResolveCommandClassForReadablePresentation(IEnumerable<MarkerClassKind>? choiceClasses, bool russian)
		{
			return ResolveCommandClassForReadablePresentation(choiceClasses, MarkerTextLocalization.FromRussianCompatibility(russian));
		}

		public static CommandClassPresentation ResolveCommandClassForReadablePresentation(IEnumerable<MarkerClassKind>? choiceClasses, MarkerLanguage language)
		{
			if (choiceClasses == null)
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedReadableClassLabel(MarkerClassKind.Unknown, language), exactClass: false);
			}
			MarkerClassKind[] array = choiceClasses.ToArray();
			if (array.Length == 0 || array.Any((MarkerClassKind x) => x == MarkerClassKind.Unknown))
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedReadableClassLabel(MarkerClassKind.Unknown, language), exactClass: false);
			}
			MarkerClassKind[] array2 = array.Distinct().ToArray();
			if (array2.Length != 1)
			{
				return new CommandClassPresentation(MarkerClassKind.Unknown, LocalizedReadableClassLabel(MarkerClassKind.Unknown, language), exactClass: false);
			}
			MarkerClassKind markerClassKind = array2[0];
			if (markerClassKind == MarkerClassKind.Other)
			{
				return new CommandClassPresentation(MarkerClassKind.Other, LocalizedReadableClassLabel(MarkerClassKind.Other, language), exactClass: false);
			}
			return new CommandClassPresentation(markerClassKind, LocalizedReadableClassLabel(markerClassKind, language), exactClass: true);
		}
	}
	public enum MarkerPresentationMode
	{
		Detailed,
		Compact
	}
	public enum MarkerCompactMixedStyle
	{
		NeutralSingleDiamond,
		CategoryDiamonds,
		CategoryDiamondPyramid
	}
	public enum MarkerCountRenderSource
	{
		None,
		TotalCountText,
		CategorySubcounts,
		DetailedCategoryRows
	}
	public enum MarkerPresentationGlyphKind
	{
		Diamond,
		Clock
	}
	public readonly struct MarkerPresentationSettings
	{
		public MarkerPresentationMode Mode { get; }

		public bool ShowDistance { get; }

		public float Scale { get; }

		public int DetailRows { get; }

		public bool ShowCategoryDiamond { get; }

		public bool ShowTierComposition { get; }

		public bool CompactShowCount { get; }

		public MarkerCompactMixedStyle CompactMixedStyle { get; }

		public MarkerCategorySortOrder CategorySortOrder { get; }

		public bool UseCategorySummaryPresentation { get; }

		public MarkerPresentationSettings(MarkerPresentationMode mode, bool showDistance, float scale, int detailRows)
			: this(mode, showDistance, scale, detailRows, showCategoryDiamond: true, showTierComposition: true, compactShowCount: true, MarkerCompactMixedStyle.NeutralSingleDiamond, MarkerCategorySortOrder.HighToLow, useCategorySummaryPresentation: false)
		{
		}

		public MarkerPresentationSettings(MarkerPresentationMode mode, bool showDistance, float scale, int detailRows, bool showCategoryDiamond, bool showTierComposition, bool compactShowCount, MarkerCompactMixedStyle compactMixedStyle)
			: this(mode, showDistance, scale, detailRows, showCategoryDiamond, showTierComposition, compactShowCount, compactMixedStyle, MarkerCategorySortOrder.HighToLow, useCategorySummaryPresentation: false)
		{
		}

		public MarkerPresentationSettings(MarkerPresentationMode mode, bool showDistance, float scale, int detailRows, bool showCategoryDiamond, bool showTierComposition, bool compactShowCount, MarkerCompactMixedStyle compactMixedStyle, MarkerCategorySortOrder categorySortOrder)
			: this(mode, showDistance, scale, detailRows, showCategoryDiamond, showTierComposition, compactShowCount, compactMixedStyle, categorySortOrder, useCategorySummaryPresentation: true)
		{
		}

		private MarkerPresentationSettings(MarkerPresentationMode mode, bool showDistance, float scale, int detailRows, bool showCategoryDiamond, bool showTierComposition, bool compactShowCount, MarkerCompactMixedStyle compactMixedStyle, MarkerCategorySortOrder categorySortOrder, bool useCategorySummaryPresentation)
		{
			Mode = mode;
			ShowDistance = showDistance;
			Scale = MarkerClusterPresentationPolicy.ClampMarkerScale(scale);
			DetailRows = MarkerClusterPresentationPolicy.ClampDetailRows(detailRows);
			ShowCategoryDiamond = showCategoryDiamond;
			ShowTierComposition = showTierComposition;
			CompactShowCount = compactShowCount;
			CompactMixedStyle = compactMixedStyle;
			CategorySortOrder = categorySortOrder;
			UseCategorySummaryPresentation = useCategorySummaryPresentation;
		}
	}
	public readonly struct MarkerCompactCategoryBadge
	{
		public MarkerSemanticCategory Category { get; }

		public int Count { get; }

		public int DisplayPriority { get; }

		public MarkerLifetimeKind Lifetime { get; }

		public MarkerPresentationGlyphKind GlyphKind { get; }

		public MarkerLifetimeIndicatorSpec LifetimeIndicator { get; }

		public float PyramidVerticalOffsetUnits => MarkerCategorySummaryPolicy.PyramidVerticalOffsetUnits(Category);

		public MarkerCompactCategoryBadge(MarkerSemanticCategory category, int count)
			: this(category, count, MarkerCategorySummaryPolicy.DisplayPriority(category), MarkerLifetimeKind.Permanent, MarkerPresentationGlyphKind.Diamond)
		{
		}

		public MarkerCompactCategoryBadge(MarkerSemanticCategory category, int count, int displayPriority)
			: this(category, count, displayPriority, MarkerLifetimeKind.Permanent, MarkerPresentationGlyphKind.Diamond)
		{
		}

		public MarkerCompactCategoryBadge(MarkerSemanticCategory category, int count, int displayPriority, MarkerLifetimeIndicatorSpec lifetimeIndicator)
			: this(category, count, displayPriority, lifetimeIndicator.Visible ? MarkerLifetimeKind.Temporary : MarkerLifetimeKind.Permanent, lifetimeIndicator.Visible ? MarkerPresentationGlyphKind.Clock : MarkerPresentationGlyphKind.Diamond)
		{
		}

		public MarkerCompactCategoryBadge(MarkerSemanticCategory category, int count, int displayPriority, MarkerLifetimeKind lifetime, MarkerPresentationGlyphKind glyphKind)
		{
			Category = category;
			Count = Math.Max(0, count);
			DisplayPriority = displayPriority;
			Lifetime = lifetime;
			GlyphKind = glyphKind;
			LifetimeIndicator = MarkerLifetimeIndicatorSpec.Hidden;
		}
	}
	public readonly struct MarkerDetailedItemRow
	{
		public string ItemIdentity { get; }

		public string LocalizedName { get; }

		public MarkerSemanticCategory Category { get; }

		public int Count { get; }

		public MarkerLifetimeKind Lifetime { get; }

		public MarkerPresentationGlyphKind GlyphKind { get; }

		public string DisplayLabel { get; }

		public MarkerLifetimeIndicatorSpec LifetimeIndicator { get; }

		public MarkerDetailedItemRow(string itemIdentity, string localizedName, MarkerSemanticCategory category, int count)
			: this(itemIdentity, localizedName, category, count, MarkerLifetimeKind.Permanent, localizedName)
		{
		}

		public MarkerDetailedItemRow(string itemIdentity, string localizedName, MarkerSemanticCategory category, int count, MarkerLifetimeKind lifetime, string displayLabel)
		{
			ItemIdentity = itemIdentity ?? string.Empty;
			LocalizedName = (string.IsNullOrWhiteSpace(localizedName) ? "Pickup" : localizedName);
			Category = category;
			Count = Math.Max(0, count);
			Lifetime = lifetime;
			GlyphKind = ((lifetime == MarkerLifetimeKind.Temporary) ? MarkerPresentationGlyphKind.Clock : MarkerPresentationGlyphKind.Diamond);
			DisplayLabel = (string.IsNullOrWhiteSpace(displayLabel) ? LocalizedName : displayLabel);
			LifetimeIndicator = MarkerLifetimePolicy.BuildIndicator(lifetime, (lifetime == MarkerLifetimeKind.Temporary) ? Count : 0, (lifetime == MarkerLifetimeKind.Mixed) ? Count : 0, (lifetime == MarkerLifetimeKind.Unknown) ? Count : 0, allowCount: false, showSingleCountWhenMixed: false);
		}
	}
	public sealed class MarkerClusterPresentationPlan
	{
		public string Text { get; }

		public IReadOnlyList<MarkerCompactCategoryBadge> CompactBadges { get; }

		public IReadOnlyList<MarkerCompactCategoryBadge> CategoryEntries => CompactBadges;

		public IReadOnlyList<MarkerDetailedItemRow> DetailedItemRows { get; }

		public int TotalCount { get; }

		public int ShownDetailRows { get; }

		public int OverflowPhysicalCount { get; }

		public bool Expanded { get; }

		public bool NeutralMainSemantic { get; }

		public MarkerCountRenderSource CountRenderSource { get; }

		public bool ShowMainDiamond { get; }

		public bool ShowDetailedCategoryRowDiamonds { get; }

		public bool ShowCompactCategoryDiamonds { get; }

		public MarkerSemanticCategory MainCategory { get; }

		public MarkerLifetimeIndicatorSpec LifetimeIndicator { get; private set; }

		public bool RenderCategorySubcounts => CountRenderSource == MarkerCountRenderSource.CategorySubcounts;

		public bool RenderTotalCount => CountRenderSource == MarkerCountRenderSource.TotalCountText;

		internal MarkerClusterPresentationPlan(string text, MarkerCompactCategoryBadge[] compactBadges, int totalCount, int shownDetailRows, int overflowPhysicalCount, bool expanded, bool neutralMainSemantic, MarkerCountRenderSource countRenderSource, bool showMainDiamond, bool showDetailedCategoryRowDiamonds, bool showCompactCategoryDiamonds, MarkerSemanticCategory mainCategory)
			: this(text, compactBadges, Array.Empty<MarkerDetailedItemRow>(), totalCount, shownDetailRows, overflowPhysicalCount, expanded, neutralMainSemantic, countRenderSource, showMainDiamond, showDetailedCategoryRowDiamonds, showCompactCategoryDiamonds, mainCategory)
		{
		}

		internal MarkerClusterPresentationPlan(string text, MarkerCompactCategoryBadge[] compactBadges, MarkerDetailedItemRow[] detailedItemRows, int totalCount, int shownDetailRows, int overflowPhysicalCount, bool expanded, bool neutralMainSemantic, MarkerCountRenderSource countRenderSource, bool showMainDiamond, bool showDetailedCategoryRowDiamonds, bool showCompactCategoryDiamonds, MarkerSemanticCategory mainCategory)
		{
			Text = text ?? string.Empty;
			CompactBadges = compactBadges ?? Array.Empty<MarkerCompactCategoryBadge>();
			DetailedItemRows = detailedItemRows ?? Array.Empty<MarkerDetailedItemRow>();
			TotalCount = Math.Max(0, totalCount);
			ShownDetailRows = Math.Max(0, shownDetailRows);
			OverflowPhysicalCount = Math.Max(0, overflowPhysicalCount);
			Expanded = expanded;
			NeutralMainSemantic = neutralMainSemantic;
			CountRenderSource = countRenderSource;
			ShowMainDiamond = showMainDiamond;
			ShowDetailedCategoryRowDiamonds = showDetailedCategoryRowDiamonds;
			ShowCompactCategoryDiamonds = showCompactCategoryDiamonds;
			MainCategory = mainCategory;
			LifetimeIndicator = MarkerLifetimeIndicatorSpec.Hidden;
		}

		internal void SetLifetimeIndicator(MarkerLifetimeIndicatorSpec lifetimeIndicator)
		{
			LifetimeIndicator = lifetimeIndicator;
		}
	}
	public static class MarkerClusterPresentationPolicy
	{
		public const int TOTAL_COUNT_RENDER_SLOTS_PER_PRESENTATION_NODE = 1;

		public const float MarkerScaleMin = 0.75f;

		public const float MarkerScaleMax = 1.25f;

		public const float MarkerScaleDefault = 1f;

		public const int MarkerDetailRowsMin = 1;

		public const int MarkerDetailRowsMax = 12;

		public const int MarkerDetailRowsDefault = 5;

		public const int DetailedCompositionLineCharacterBudget = 48;

		public const int MaxCompositionLines = 2;

		public const int MaxCompactCategoryBadges = 11;

		public const int MaxCompactLifetimePresentationGroups = 22;

		public const float DetailedItemLabelMaxWidth1080 = 420f;

		public const float DetailedItemLabelMinWidth1080 = 180f;

		public static float ClampMarkerScale(float value)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return 1f;
			}
			if (value < 0.75f)
			{
				return 0.75f;
			}
			if (!(value > 1.25f))
			{
				return value;
			}
			return 1.25f;
		}

		public static int ClampDetailRows(int value)
		{
			if (value < 1)
			{
				return 1;
			}
			if (value <= 12)
			{
				return value;
			}
			return 12;
		}

		public static float BuildDetailedItemLabelWidthLimit(float screenWidth, float screenHeight, float markerScale)
		{
			float num = ((float.IsNaN(screenWidth) || float.IsInfinity(screenWidth) || screenWidth <= 0f) ? 1920f : screenWidth);
			float num2 = ((float.IsNaN(screenHeight) || float.IsInfinity(screenHeight) || screenHeight <= 0f) ? 1080f : screenHeight);
			float num3 = Math.Min(num / 1920f, num2 / 1080f);
			if (num3 <= 0f || float.IsNaN(num3) || float.IsInfinity(num3))
			{
				num3 = 1f;
			}
			float num4 = ClampMarkerScale(markerScale);
			float val = 420f * num3 * num4;
			float val2 = 180f * num3 * num4;
			float val3 = num * 0.34f;
			return Math.Max(val2, Math.Min(val, val3));
		}

		public static MarkerClusterPresentationPlan Build(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, bool expanded, bool russian)
		{
			return Build(cluster, settings, distanceMeters, expanded, MarkerTextLocalization.FromRussianCompatibility(russian));
		}

		public static MarkerClusterPresentationPlan Build(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, bool expanded, MarkerLanguage language)
		{
			if (cluster == null)
			{
				throw new ArgumentNullException("cluster");
			}
			MarkerClusterPresentationPlan markerClusterPresentationPlan = ((!settings.UseCategorySummaryPresentation) ? ((settings.Mode == MarkerPresentationMode.Compact) ? BuildCompactLegacy(cluster, settings, distanceMeters, expanded, language) : BuildDetailedLegacy(cluster, settings, distanceMeters, expanded, language)) : ((settings.Mode == MarkerPresentationMode.Compact) ? BuildCompactCategoryPyramid(cluster, settings, distanceMeters, language) : BuildDetailedCategorySummary(cluster, settings, distanceMeters, language)));
			if ((settings.Mode == MarkerPresentationMode.Compact && !markerClusterPresentationPlan.ShowCompactCategoryDiamonds) || (settings.Mode == MarkerPresentationMode.Detailed && markerClusterPresentationPlan.DetailedItemRows.Count == 0 && !markerClusterPresentationPlan.ShowDetailedCategoryRowDiamonds))
			{
				markerClusterPresentationPlan.SetLifetimeIndicator(BuildClusterLifetimeIndicator(cluster, settings.Mode == MarkerPresentationMode.Compact && settings.CompactShowCount, showSingleCountWhenMixed: true));
			}
			return markerClusterPresentationPlan;
		}

		public static MarkerClusterPresentationPlan BuildOffscreen(int nearestDistanceMeters, int sectorTotalCount, bool showDistance, bool showTotalCount, bool russian)
		{
			return BuildOffscreen(nearestDistanceMeters, sectorTotalCount, showDistance, showTotalCount, MarkerTextLocalization.FromRussianCompatibility(russian), MarkerLifetimeKind.Permanent, 0, 0, 0);
		}

		public static MarkerClusterPresentationPlan BuildOffscreen(int nearestDistanceMeters, int sectorTotalCount, bool showDistance, bool showTotalCount, MarkerLanguage language)
		{
			return BuildOffscreen(nearestDistanceMeters, sectorTotalCount, showDistance, showTotalCount, language, MarkerLifetimeKind.Permanent, 0, 0, 0);
		}

		public static MarkerClusterPresentationPlan BuildOffscreen(int nearestDistanceMeters, int sectorTotalCount, bool showDistance, bool showTotalCount, bool russian, MarkerLifetimeKind lifetime, int temporaryPhysicalMembers, int mixedLifetimeMembers, int unknownLifetimeMembers)
		{
			return BuildOffscreen(nearestDistanceMeters, sectorTotalCount, showDistance, showTotalCount, MarkerTextLocalization.FromRussianCompatibility(russian), lifetime, temporaryPhysicalMembers, mixedLifetimeMembers, unknownLifetimeMembers);
		}

		public static MarkerClusterPresentationPlan BuildOffscreen(int nearestDistanceMeters, int sectorTotalCount, bool showDistance, bool showTotalCount, MarkerLanguage language, MarkerLifetimeKind lifetime, int temporaryPhysicalMembers, int mixedLifetimeMembers, int unknownLifetimeMembers)
		{
			StringBuilder stringBuilder = new StringBuilder(32);
			MarkerCountRenderSource countRenderSource = MarkerCountRenderSource.None;
			if (showTotalCount)
			{
				stringBuilder.Append('×').Append(Math.Max(0, sectorTotalCount).ToString(CultureInfo.InvariantCulture));
				countRenderSource = MarkerCountRenderSource.TotalCountText;
			}
			if (showDistance)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append('\n');
				}
				stringBuilder.Append(Math.Max(0, nearestDistanceMeters).ToString(CultureInfo.InvariantCulture)).Append(" ").Append(MarkerTextLocalization.DistanceUnit(language));
			}
			MarkerClusterPresentationPlan markerClusterPresentationPlan = new MarkerClusterPresentationPlan(stringBuilder.ToString(), Array.Empty<MarkerCompactCategoryBadge>(), Math.Max(0, sectorTotalCount), 0, 0, expanded: false, neutralMainSemantic: true, countRenderSource, showMainDiamond: true, showDetailedCategoryRowDiamonds: false, showCompactCategoryDiamonds: false, MarkerSemanticCategory.Unknown);
			markerClusterPresentationPlan.SetLifetimeIndicator((lifetime == MarkerLifetimeKind.Temporary) ? MarkerLifetimePolicy.BuildIndicator(MarkerLifetimeKind.Temporary, temporaryPhysicalMembers, 0, 0, showTotalCount, showSingleCountWhenMixed: false) : MarkerLifetimeIndicatorSpec.Hidden);
			return markerClusterPresentationPlan;
		}

		public static string LocalizedCategoryPlural(MarkerSemanticCategory category, bool russian)
		{
			return LocalizedCategoryPlural(category, MarkerTextLocalization.FromRussianCompatibility(russian));
		}

		public static string LocalizedCategoryPlural(MarkerSemanticCategory category, MarkerLanguage language)
		{
			return MarkerTextLocalization.CategoryPlural(category, language);
		}

		public static string LocalizedCompositionWord(MarkerSemanticCategory category, bool russian)
		{
			return LocalizedCompositionWord(category, MarkerTextLocalization.FromRussianCompatibility(russian));
		}

		public static string LocalizedCompositionWord(MarkerSemanticCategory category, MarkerLanguage language)
		{
			return MarkerTextLocalization.CompositionLabel(category, language);
		}

		public static int CompositionCountSum(IReadOnlyList<MarkerCategoryCount> composition)
		{
			if (composition == null)
			{
				throw new ArgumentNullException("composition");
			}
			int num = 0;
			for (int i = 0; i < composition.Count; i++)
			{
				num += Math.Max(0, composition[i].Count);
			}
			return num;
		}

		public static string LocalizedCategorySummaryLabel(MarkerSemanticCategory category, bool russian)
		{
			return LocalizedCategorySummaryLabel(category, MarkerTextLocalization.FromRussianCompatibility(russian));
		}

		public static string LocalizedCategorySummaryLabel(MarkerSemanticCategory category, MarkerLanguage language)
		{
			return MarkerTextLocalization.CategorySummaryLabel(category, language);
		}

		private static MarkerClusterPresentationPlan BuildDetailedCategorySummary(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, MarkerLanguage language)
		{
			if (!IsCommandChoiceCluster(cluster))
			{
				return BuildDetailedOrdinaryItemSummary(cluster, settings, distanceMeters, language);
			}
			return BuildDetailedCommandCategorySummary(cluster, settings, distanceMeters, language);
		}

		private static MarkerClusterPresentationPlan BuildDetailedCommandCategorySummary(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, MarkerLanguage language)
		{
			StringBuilder stringBuilder = new StringBuilder(160);
			int totalCount = cluster.TotalCount;
			bool flag = cluster.IsMixedCategory || cluster.HomogeneousCategory == MarkerSemanticCategory.Unknown || cluster.HomogeneousCategory == MarkerSemanticCategory.CommandState;
			MarkerSemanticCategory mainCategory = (flag ? MarkerSemanticCategory.Unknown : cluster.HomogeneousCategory);
			MarkerCompactCategoryBadge[] array = BuildCategoryEntriesWithLifetime(cluster, settings.CategorySortOrder);
			if (totalCount <= 1 && IsTruthfulConcreteSingleAggregate(cluster))
			{
				stringBuilder.Append(cluster.ItemRows[0].LocalizedName).Append(" ×").Append(totalCount.ToString(CultureInfo.InvariantCulture));
				AppendDistance(stringBuilder, settings.ShowDistance, distanceMeters, language);
				return new MarkerClusterPresentationPlan(stringBuilder.ToString(), array, totalCount, 0, 0, expanded: false, flag, MarkerCountRenderSource.TotalCountText, settings.ShowCategoryDiamond, showDetailedCategoryRowDiamonds: false, showCompactCategoryDiamonds: false, mainCategory);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append('\n');
				}
				stringBuilder.Append(LocalizedCategorySummaryLabel(array[i].Category, language)).Append(" ×").Append(array[i].Count.ToString(CultureInfo.InvariantCulture));
			}
			AppendDistance(stringBuilder, settings.ShowDistance, distanceMeters, language);
			return new MarkerClusterPresentationPlan(stringBuilder.ToString(), array, totalCount, 0, 0, expanded: false, flag, MarkerCountRenderSource.DetailedCategoryRows, showMainDiamond: false, settings.ShowCategoryDiamond, showCompactCategoryDiamonds: false, mainCategory);
		}

		private static MarkerClusterPresentationPlan BuildDetailedOrdinaryItemSummary(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, MarkerLanguage language)
		{
			List<MarkerDetailedItemRow> list = new List<MarkerDetailedItemRow>(cluster.ItemRows.Count);
			for (int i = 0; i < cluster.ItemRows.Count; i++)
			{
				MarkerItemAggregate markerItemAggregate = cluster.ItemRows[i];
				if (markerItemAggregate.Count > 0)
				{
					list.Add(new MarkerDetailedItemRow(markerItemAggregate.ItemIdentity, markerItemAggregate.LocalizedName, markerItemAggregate.Category, markerItemAggregate.Count, markerItemAggregate.Lifetime, MarkerLifetimePolicy.BuildDetailedItemDisplayName(string.IsNullOrWhiteSpace(markerItemAggregate.LocalizedName) ? MarkerTextLocalization.FallbackPickup(language) : markerItemAggregate.LocalizedName, markerItemAggregate.Lifetime, language == MarkerLanguage.Russian)));
				}
			}
			list.Sort((MarkerDetailedItemRow left, MarkerDetailedItemRow right) => CompareDetailedItems(left, right, settings.CategorySortOrder));
			int num = Math.Min(settings.DetailRows, list.Count);
			int num2 = Math.Max(0, list.Count - num);
			StringBuilder stringBuilder = new StringBuilder(192);
			for (int num3 = 0; num3 < num; num3++)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append('\n');
				}
				stringBuilder.Append(list[num3].DisplayLabel).Append(" ×").Append(list[num3].Count.ToString(CultureInfo.InvariantCulture));
			}
			if (num2 > 0)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append('\n');
				}
				stringBuilder.Append(BuildDetailedOverflowText(num2, language));
			}
			AppendDistance(stringBuilder, settings.ShowDistance, distanceMeters, language);
			MarkerDetailedItemRow[] array = new MarkerDetailedItemRow[num];
			for (int num4 = 0; num4 < num; num4++)
			{
				array[num4] = list[num4];
			}
			bool flag = cluster.IsMixedCategory || cluster.HomogeneousCategory == MarkerSemanticCategory.Unknown;
			MarkerSemanticCategory mainCategory = (flag ? MarkerSemanticCategory.Unknown : cluster.HomogeneousCategory);
			return new MarkerClusterPresentationPlan(stringBuilder.ToString(), Array.Empty<MarkerCompactCategoryBadge>(), array, cluster.TotalCount, num, num2, expanded: false, flag, MarkerCountRenderSource.None, showMainDiamond: false, showDetailedCategoryRowDiamonds: false, showCompactCategoryDiamonds: false, mainCategory);
		}

		public static string BuildDetailedOverflowText(int hiddenDistinctTypes, bool russian)
		{
			return BuildDetailedOverflowText(hiddenDistinctTypes, MarkerTextLocalization.FromRussianCompatibility(russian));
		}

		public static string BuildDetailedOverflowText(int hiddenDistinctTypes, MarkerLanguage language)
		{
			return MarkerTextLocalization.FormatMoreTypes(hiddenDistinctTypes, language);
		}

		public static string RussianDistinctTypeWord(int hiddenDistinctTypes)
		{
			return MarkerTextLocalization.RussianDistinctTypeWord(hiddenDistinctTypes);
		}

		private static int CompareDetailedItems(MarkerDetailedItemRow left, MarkerDetailedItemRow right, MarkerCategorySortOrder sortOrder)
		{
			int value = MarkerCategorySummaryPolicy.DisplayPriority(left.Category);
			int num = MarkerCategorySummaryPolicy.DisplayPriority(right.Category).CompareTo(value);
			if (sortOrder == MarkerCategorySortOrder.LowToHigh)
			{
				num = -num;
			}
			if (num != 0)
			{
				return num;
			}
			int num2 = string.Compare(left.LocalizedName, right.LocalizedName, StringComparison.Ordinal);
			if (num2 != 0)
			{
				return num2;
			}
			int num3 = string.Compare(left.ItemIdentity, right.ItemIdentity, StringComparison.Ordinal);
			if (num3 != 0)
			{
				return num3;
			}
			return MarkerLifetimePolicy.DetailedSortRank(left.Lifetime).CompareTo(MarkerLifetimePolicy.DetailedSortRank(right.Lifetime));
		}

		private static bool IsCommandChoiceCluster(MarkerSemanticCluster cluster)
		{
			if (cluster.ItemRows.Count == 0)
			{
				return cluster.HomogeneousCategory == MarkerSemanticCategory.CommandState;
			}
			for (int i = 0; i < cluster.ItemRows.Count; i++)
			{
				if (!(cluster.ItemRows[i].ItemIdentity ?? string.Empty).StartsWith("COMMAND:", StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
			}
			return true;
		}

		private static MarkerClusterPresentationPlan BuildCompactCategoryPyramid(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, MarkerLanguage language)
		{
			int totalCount = cluster.TotalCount;
			MarkerCompactCategoryBadge[] compactBadges = BuildCategoryEntriesWithLifetime(cluster, settings.CategorySortOrder);
			bool flag = cluster.IsMixedCategory || cluster.HomogeneousCategory == MarkerSemanticCategory.Unknown || cluster.HomogeneousCategory == MarkerSemanticCategory.CommandState;
			MarkerSemanticCategory mainCategory = (flag ? MarkerSemanticCategory.Unknown : cluster.HomogeneousCategory);
			StringBuilder stringBuilder = new StringBuilder(48);
			AppendDistance(stringBuilder, settings.ShowDistance, distanceMeters, language);
			return new MarkerClusterPresentationPlan(stringBuilder.ToString(), compactBadges, totalCount, 0, 0, expanded: false, flag, settings.CompactShowCount ? MarkerCountRenderSource.CategorySubcounts : MarkerCountRenderSource.None, showMainDiamond: false, showDetailedCategoryRowDiamonds: false, showCompactCategoryDiamonds: true, mainCategory);
		}

		private static MarkerClusterPresentationPlan BuildDetailedLegacy(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, bool expanded, MarkerLanguage language)
		{
			StringBuilder stringBuilder = new StringBuilder(192);
			int totalCount = cluster.TotalCount;
			bool flag = cluster.IsMixedCategory || cluster.HomogeneousCategory == MarkerSemanticCategory.Unknown || cluster.HomogeneousCategory == MarkerSemanticCategory.CommandState;
			MarkerSemanticCategory mainCategory = (flag ? MarkerSemanticCategory.Unknown : cluster.HomogeneousCategory);
			if (IsTruthfulConcreteSingleAggregate(cluster))
			{
				stringBuilder.Append(cluster.ItemRows[0].LocalizedName).Append(" ×").Append(totalCount.ToString(CultureInfo.InvariantCulture));
			}
			else if (cluster.IsHomogeneousCategory)
			{
				stringBuilder.Append(LocalizedCategoryPlural(cluster.HomogeneousCategory, language)).Append(" ×").Append(totalCount.ToString(CultureInfo.InvariantCulture));
			}
			else
			{
				stringBuilder.Append(MarkerTextLocalization.GenericItems(language)).Append(" ×").Append(totalCount.ToString(CultureInfo.InvariantCulture));
				if (settings.ShowTierComposition)
				{
					AppendDetailedComposition(stringBuilder, cluster.Composition, language);
				}
			}
			int shownRows = 0;
			int overflowPhysicalCount = 0;
			if (expanded && totalCount > 1)
			{
				AppendExpandedDetailRows(stringBuilder, cluster.ItemRows, settings.DetailRows, totalCount, language, out shownRows, out overflowPhysicalCount);
			}
			AppendDistance(stringBuilder, settings.ShowDistance, distanceMeters, language);
			return new MarkerClusterPresentationPlan(stringBuilder.ToString(), Array.Empty<MarkerCompactCategoryBadge>(), totalCount, shownRows, overflowPhysicalCount, expanded, flag, MarkerCountRenderSource.TotalCountText, settings.ShowCategoryDiamond, showDetailedCategoryRowDiamonds: false, showCompactCategoryDiamonds: false, mainCategory);
		}

		private static MarkerClusterPresentationPlan BuildCompactLegacy(MarkerSemanticCluster cluster, MarkerPresentationSettings settings, int distanceMeters, bool expanded, MarkerLanguage language)
		{
			int totalCount = cluster.TotalCount;
			MarkerCompactCategoryBadge[] compactBadges = BuildCategoryEntriesWithLifetime(cluster, MarkerCategorySortOrder.HighToLow, preserveCompositionOrder: true);
			bool flag = cluster.IsMixedCategory && settings.CompactMixedStyle == MarkerCompactMixedStyle.CategoryDiamonds;
			MarkerCountRenderSource markerCountRenderSource = ((!flag) ? (settings.CompactShowCount ? MarkerCountRenderSource.TotalCountText : MarkerCountRenderSource.None) : (settings.CompactShowCount ? MarkerCountRenderSource.CategorySubcounts : MarkerCountRenderSource.None));
			StringBuilder stringBuilder = new StringBuilder(160);
			if (markerCountRenderSource == MarkerCountRenderSource.TotalCountText)
			{
				stringBuilder.Append('×').Append(totalCount.ToString(CultureInfo.InvariantCulture));
			}
			int shownRows = 0;
			int overflowPhysicalCount = 0;
			if (expanded)
			{
				AppendExpandedDetailRows(stringBuilder, cluster.ItemRows, settings.DetailRows, totalCount, language, out shownRows, out overflowPhysicalCount);
			}
			AppendDistance(stringBuilder, settings.ShowDistance, distanceMeters, language);
			bool flag2 = cluster.IsMixedCategory || cluster.HomogeneousCategory == MarkerSemanticCategory.Unknown || cluster.HomogeneousCategory == MarkerSemanticCategory.CommandState;
			MarkerSemanticCategory mainCategory = (flag2 ? MarkerSemanticCategory.Unknown : cluster.HomogeneousCategory);
			return new MarkerClusterPresentationPlan(stringBuilder.ToString(), compactBadges, totalCount, shownRows, overflowPhysicalCount, expanded, flag2, markerCountRenderSource, !flag, showDetailedCategoryRowDiamonds: false, flag, mainCategory);
		}

		private static bool IsTruthfulConcreteSingleAggregate(MarkerSemanticCluster cluster)
		{
			if (cluster.ItemRows.Count != 1 || !cluster.IsHomogeneousCategory)
			{
				return false;
			}
			if (cluster.HomogeneousCategory == MarkerSemanticCategory.CommandState || cluster.HomogeneousCategory == MarkerSemanticCategory.Unknown)
			{
				return false;
			}
			string text = cluster.ItemRows[0].ItemIdentity ?? string.Empty;
			if (!text.StartsWith("COMMAND:", StringComparison.OrdinalIgnoreCase))
			{
				return !text.StartsWith("UNKNOWN:", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static void AppendExpandedDetailRows(StringBuilder builder, IReadOnlyList<MarkerItemAggregate> itemRows, int requestedRows, int totalPhysicalCount, MarkerLanguage language, out int shownRows, out int overflowPhysicalCount)
		{
			int num = Math.Min(ClampDetailRows(requestedRows), 12);
			Span<int> span = stackalloc int[12];
			for (int i = 0; i < span.Length; i++)
			{
				span[i] = -1;
			}
			int num2 = 0;
			for (int j = 0; j < itemRows.Count; j++)
			{
				MarkerItemAggregate left = itemRows[j];
				if (left.Count <= 0)
				{
					continue;
				}
				int num3 = num2;
				for (int k = 0; k < num2; k++)
				{
					if (CompareExpandedDetailPriority(left, itemRows[span[k]]) < 0)
					{
						num3 = k;
						break;
					}
				}
				if (num3 < num)
				{
					if (num2 < num)
					{
						num2++;
					}
					for (int num4 = num2 - 1; num4 > num3; num4--)
					{
						span[num4] = span[num4 - 1];
					}
					span[num3] = j;
				}
			}
			int num5 = 0;
			for (int l = 0; l < num2; l++)
			{
				MarkerItemAggregate markerItemAggregate = itemRows[span[l]];
				if (builder.Length > 0)
				{
					builder.Append('\n');
				}
				builder.Append(markerItemAggregate.LocalizedName);
				if (markerItemAggregate.Count > 1)
				{
					builder.Append(" ×").Append(markerItemAggregate.Count.ToString(CultureInfo.InvariantCulture));
				}
				num5 += markerItemAggregate.Count;
			}
			shownRows = num2;
			overflowPhysicalCount = Math.Max(0, totalPhysicalCount - num5);
			if (overflowPhysicalCount > 0)
			{
				if (builder.Length > 0)
				{
					builder.Append('\n');
				}
				builder.Append(MarkerTextLocalization.FormatPhysicalItems(overflowPhysicalCount, language));
			}
		}

		private static int CompareExpandedDetailPriority(MarkerItemAggregate left, MarkerItemAggregate right)
		{
			int num = right.Count.CompareTo(left.Count);
			if (num != 0)
			{
				return num;
			}
			int num2 = MarkerSemanticCategoryPolicy.StableOrder(left.Category).CompareTo(MarkerSemanticCategoryPolicy.StableOrder(right.Category));
			if (num2 != 0)
			{
				return num2;
			}
			int num3 = string.Compare(left.LocalizedName, right.LocalizedName, StringComparison.Ordinal);
			if (num3 != 0)
			{
				return num3;
			}
			return string.Compare(left.ItemIdentity, right.ItemIdentity, StringComparison.Ordinal);
		}

		private static void AppendDetailedComposition(StringBuilder builder, IReadOnlyList<MarkerCategoryCount> composition, MarkerLanguage language)
		{
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < composition.Count; i++)
			{
				MarkerCategoryCount markerCategoryCount = composition[i];
				if (markerCategoryCount.Count > 0)
				{
					string text = LocalizedCompositionWord(markerCategoryCount.Category, language) + " " + markerCategoryCount.Count.ToString(CultureInfo.InvariantCulture);
					int num3 = ((num != 0) ? 3 : 0);
					if (num > 0 && num + num3 + text.Length > 48 && num2 + 1 < 2)
					{
						builder.Append('\n');
						num = 0;
						num2++;
						num3 = 0;
					}
					else if (num == 0)
					{
						builder.Append('\n');
					}
					if (num > 0)
					{
						builder.Append(" · ");
					}
					builder.Append(text);
					num += num3 + text.Length;
				}
			}
		}

		private static MarkerCompactCategoryBadge[] BuildCategoryEntriesWithLifetime(MarkerSemanticCluster cluster, MarkerCategorySortOrder sortOrder, bool preserveCompositionOrder = false)
		{
			MarkerCompactCategoryBadge[] array;
			if (preserveCompositionOrder)
			{
				int num = 0;
				for (int i = 0; i < cluster.Composition.Count; i++)
				{
					if (num >= 11)
					{
						break;
					}
					if (cluster.Composition[i].Count > 0)
					{
						num++;
					}
				}
				array = new MarkerCompactCategoryBadge[num];
				int num2 = 0;
				for (int j = 0; j < cluster.Composition.Count; j++)
				{
					if (num2 >= array.Length)
					{
						break;
					}
					MarkerCategoryCount markerCategoryCount = cluster.Composition[j];
					if (markerCategoryCount.Count > 0)
					{
						array[num2++] = new MarkerCompactCategoryBadge(markerCategoryCount.Category, markerCategoryCount.Count, MarkerCategorySummaryPolicy.DisplayPriority(markerCategoryCount.Category));
					}
				}
			}
			else
			{
				array = MarkerCategorySummaryPolicy.BuildCategoryEntries(cluster.Composition, sortOrder);
			}
			if (array.Length == 0)
			{
				return array;
			}
			List<MarkerCompactCategoryBadge> list = new List<MarkerCompactCategoryBadge>(Math.Min(22, array.Length * 2));
			for (int k = 0; k < array.Length; k++)
			{
				if (list.Count >= 22)
				{
					break;
				}
				MarkerCompactCategoryBadge markerCompactCategoryBadge = array[k];
				int num3 = 0;
				int num4 = 0;
				int num5 = 0;
				for (int l = 0; l < cluster.ItemRows.Count; l++)
				{
					MarkerItemAggregate markerItemAggregate = cluster.ItemRows[l];
					if (markerItemAggregate.Category == markerCompactCategoryBadge.Category && markerItemAggregate.Count > 0)
					{
						switch (markerItemAggregate.Lifetime)
						{
						case MarkerLifetimeKind.Temporary:
							num3 += markerItemAggregate.Count;
							break;
						case MarkerLifetimeKind.Permanent:
							num4 += markerItemAggregate.Count;
							break;
						default:
							num5 += markerItemAggregate.Count;
							break;
						}
					}
				}
				int num6 = Math.Max(0, num4 + num5);
				if (num6 > 0 && list.Count < 22)
				{
					MarkerLifetimeKind lifetime = ((num5 != 0) ? MarkerLifetimeKind.Unknown : MarkerLifetimeKind.Permanent);
					list.Add(new MarkerCompactCategoryBadge(markerCompactCategoryBadge.Category, num6, markerCompactCategoryBadge.DisplayPriority, lifetime, MarkerPresentationGlyphKind.Diamond));
				}
				if (num3 > 0 && list.Count < 22)
				{
					list.Add(new MarkerCompactCategoryBadge(markerCompactCategoryBadge.Category, num3, markerCompactCategoryBadge.DisplayPriority, MarkerLifetimeKind.Temporary, MarkerPresentationGlyphKind.Clock));
				}
			}
			return list.ToArray();
		}

		private static MarkerLifetimeIndicatorSpec BuildClusterLifetimeIndicator(MarkerSemanticCluster cluster, bool allowCount, bool showSingleCountWhenMixed)
		{
			return MarkerLifetimePolicy.BuildIndicator(cluster.LifetimeSummary, cluster.TemporaryPhysicalMemberCount, cluster.MixedLifetimeMemberCount, cluster.UnknownLifetimeMemberCount, allowCount, showSingleCountWhenMixed);
		}

		private static void AppendLifetimeSummary(StringBuilder builder, MarkerSemanticCluster cluster, bool showTemporaryCount, bool russian)
		{
			string value = MarkerLifetimePolicy.BuildSummaryLine(cluster.LifetimeSummary, cluster.TemporaryPhysicalMemberCount, showTemporaryCount, russian);
			if (!string.IsNullOrEmpty(value))
			{
				if (builder.Length > 0)
				{
					builder.Append('\n');
				}
				builder.Append(value);
			}
		}

		private static void AppendDistance(StringBuilder builder, bool showDistance, int distanceMeters, MarkerLanguage language)
		{
			if (showDistance)
			{
				if (builder.Length > 0)
				{
					builder.Append('\n');
				}
				builder.Append(Math.Max(0, distanceMeters).ToString(CultureInfo.InvariantCulture)).Append(" ").Append(MarkerTextLocalization.DistanceUnit(language));
			}
		}
	}
	public sealed class MarkerDenseAreaPresentationNode
	{
		public long StableKey { get; }

		public bool IsDenseSummary { get; }

		public IReadOnlyList<long> PhysicalClusterKeys { get; }

		public MarkerSemanticCluster PresentationCluster { get; }

		public MarkerWorldPoint WorldAnchor => PresentationCluster.WorldAnchor;

		public IReadOnlyList<long> MemberStableKeys => PresentationCluster.MemberStableKeys;

		public int TotalCount => PresentationCluster.TotalCount;

		public string MemberFingerprint => PresentationCluster.MemberFingerprint;

		internal MarkerDenseAreaPresentationNode(long stableKey, bool isDenseSummary, long[] physicalClusterKeys, MarkerSemanticCluster presentationCluster)
		{
			StableKey = stableKey;
			IsDenseSummary = isDenseSummary;
			PhysicalClusterKeys = physicalClusterKeys ?? Array.Empty<long>();
			PresentationCluster = presentationCluster ?? throw new ArgumentNullException("presentationCluster");
		}
	}
	public sealed class MarkerDenseAreaUpdate
	{
		public IReadOnlyList<MarkerDenseAreaPresentationNode> Nodes { get; }

		public bool MembershipChanged { get; }

		internal MarkerDenseAreaUpdate(IReadOnlyList<MarkerDenseAreaPresentationNode> nodes, bool membershipChanged)
		{
			Nodes = nodes;
			MembershipChanged = membershipChanged;
		}
	}
	public sealed class MarkerDenseAreaSummaryTracker
	{
		private readonly struct PairKey : IEquatable<PairKey>
		{
			public long A { get; }

			public long B { get; }

			public PairKey(long a, long b)
			{
				if (a <= b)
				{
					A = a;
					B = b;
				}
				else
				{
					A = b;
					B = a;
				}
			}

			public bool Equals(PairKey other)
			{
				if (A == other.A)
				{
					return B == other.B;
				}
				return false;
			}

			public override bool Equals(object? obj)
			{
				if (obj is PairKey other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (A.GetHashCode() * 397) ^ B.GetHashCode();
			}
		}

		private sealed class PairState
		{
			public bool Linked;

			public bool Pending;

			public bool PendingTarget;

			public double PendingSince;
		}

		private sealed class PreviousDenseOwner
		{
			public long OwnerKey { get; }

			public long[] MemberKeys { get; }

			public PreviousDenseOwner(long ownerKey, long[] memberKeys)
			{
				OwnerKey = ownerKey;
				MemberKeys = memberKeys;
			}
		}

		private sealed class MutableAggregate
		{
			public string ItemIdentity { get; }

			public string LocalizedName { get; }

			public MarkerSemanticCategory Category { get; }

			public MarkerLifetimeKind Lifetime { get; }

			public int Count { get; set; }

			public MutableAggregate(string itemIdentity, string localizedName, MarkerSemanticCategory category, MarkerLifetimeKind lifetime)
			{
				ItemIdentity = itemIdentity;
				LocalizedName = localizedName;
				Category = category;
				Lifetime = lifetime;
			}
		}

		public const float MergeRadiusMeters = 12f;

		public const float SplitRadiusMeters = 16f;

		public const double ThresholdTransitionDwellSeconds = 0.35;

		public const int MinimumPhysicalClustersForSummary = 2;

		private readonly List<MarkerSemanticCluster> _orderedClusters = new List<MarkerSemanticCluster>();

		private readonly Dictionary<PairKey, PairState> _pairStates = new Dictionary<PairKey, PairState>();

		private readonly List<PairKey> _stalePairs = new List<PairKey>();

		private readonly List<MarkerDenseAreaPresentationNode> _nodes = new List<MarkerDenseAreaPresentationNode>();

		private readonly List<PreviousDenseOwner> _previousDenseOwners = new List<PreviousDenseOwner>();

		private string _lastMembershipSignature = string.Empty;

		public IReadOnlyList<MarkerDenseAreaPresentationNode> Nodes => _nodes;

		public MarkerDenseAreaUpdate Update(IReadOnlyList<MarkerSemanticCluster> physicalClusters, double nowSeconds)
		{
			if (physicalClusters == null)
			{
				throw new ArgumentNullException("physicalClusters");
			}
			if (double.IsNaN(nowSeconds) || double.IsInfinity(nowSeconds))
			{
				nowSeconds = 0.0;
			}
			_orderedClusters.Clear();
			for (int i = 0; i < physicalClusters.Count; i++)
			{
				if (physicalClusters[i] != null)
				{
					_orderedClusters.Add(physicalClusters[i]);
				}
			}
			_orderedClusters.Sort((MarkerSemanticCluster left, MarkerSemanticCluster right) => left.StableKey.CompareTo(right.StableKey));
			ReconcileNewPairsImmediately();
			AdvanceExistingPairs(nowSeconds);
			PrunePairStates();
			List<MarkerDenseAreaPresentationNode> list = BuildPresentationNodes();
			string text = BuildMembershipSignature(list);
			bool membershipChanged = !string.Equals(text, _lastMembershipSignature, StringComparison.Ordinal);
			_lastMembershipSignature = text;
			_nodes.Clear();
			_nodes.AddRange(list);
			CapturePreviousDenseOwners();
			return new MarkerDenseAreaUpdate(_nodes, membershipChanged);
		}

		public void Clear()
		{
			_orderedClusters.Clear();
			_pairStates.Clear();
			_stalePairs.Clear();
			_nodes.Clear();
			_previousDenseOwners.Clear();
			_lastMembershipSignature = string.Empty;
		}

		private void ReconcileNewPairsImmediately()
		{
			float num = 144f;
			for (int i = 0; i < _orderedClusters.Count; i++)
			{
				for (int j = i + 1; j < _orderedClusters.Count; j++)
				{
					PairKey key = new PairKey(_orderedClusters[i].StableKey, _orderedClusters[j].StableKey);
					if (!_pairStates.ContainsKey(key))
					{
						_pairStates[key] = new PairState
						{
							Linked = (MarkerWorldPoint.DistanceSquared(_orderedClusters[i].WorldAnchor, _orderedClusters[j].WorldAnchor) <= num)
						};
					}
				}
			}
		}

		private void AdvanceExistingPairs(double nowSeconds)
		{
			float num = 144f;
			float num2 = 256f;
			foreach (KeyValuePair<PairKey, PairState> pairState in _pairStates)
			{
				MarkerSemanticCluster markerSemanticCluster = FindCluster(pairState.Key.A);
				MarkerSemanticCluster markerSemanticCluster2 = FindCluster(pairState.Key.B);
				if (markerSemanticCluster == null || markerSemanticCluster2 == null)
				{
					continue;
				}
				float num3 = MarkerWorldPoint.DistanceSquared(markerSemanticCluster.WorldAnchor, markerSemanticCluster2.WorldAnchor);
				PairState value = pairState.Value;
				if (value.Linked)
				{
					if (num3 <= num2)
					{
						value.Pending = false;
					}
					else
					{
						AdvancePending(value, target: false, nowSeconds);
					}
				}
				else if (num3 >= num)
				{
					value.Pending = false;
				}
				else
				{
					AdvancePending(value, target: true, nowSeconds);
				}
			}
		}

		private static void AdvancePending(PairState state, bool target, double nowSeconds)
		{
			if (!state.Pending || state.PendingTarget != target)
			{
				state.Pending = true;
				state.PendingTarget = target;
				state.PendingSince = nowSeconds;
			}
			else if (!(nowSeconds - state.PendingSince < 0.35))
			{
				state.Linked = target;
				state.Pending = false;
			}
		}

		private void PrunePairStates()
		{
			_stalePairs.Clear();
			foreach (PairKey key in _pairStates.Keys)
			{
				if (FindCluster(key.A) == null || FindCluster(key.B) == null)
				{
					_stalePairs.Add(key);
				}
			}
			for (int i = 0; i < _stalePairs.Count; i++)
			{
				_pairStates.Remove(_stalePairs[i]);
			}
		}

		private MarkerSemanticCluster? FindCluster(long key)
		{
			int num = 0;
			int num2 = _orderedClusters.Count - 1;
			while (num <= num2)
			{
				int num3 = num + (num2 - num >> 1);
				long stableKey = _orderedClusters[num3].StableKey;
				if (stableKey == key)
				{
					return _orderedClusters[num3];
				}
				if (stableKey < key)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return null;
		}

		private List<MarkerDenseAreaPresentationNode> BuildPresentationNodes()
		{
			List<MarkerDenseAreaPresentationNode> list = new List<MarkerDenseAreaPresentationNode>(_orderedClusters.Count);
			if (_orderedClusters.Count == 0)
			{
				return list;
			}
			int[] array = new int[_orderedClusters.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = i;
			}
			foreach (KeyValuePair<PairKey, PairState> pairState in _pairStates)
			{
				if (pairState.Value.Linked)
				{
					int num = IndexOfCluster(pairState.Key.A);
					int num2 = IndexOfCluster(pairState.Key.B);
					if (num >= 0 && num2 >= 0)
					{
						Union(array, num, num2);
					}
				}
			}
			Dictionary<int, List<MarkerSemanticCluster>> dictionary = new Dictionary<int, List<MarkerSemanticCluster>>();
			for (int j = 0; j < _orderedClusters.Count; j++)
			{
				int key = Find(array, j);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = new List<MarkerSemanticCluster>();
					dictionary.Add(key, value);
				}
				value.Add(_orderedClusters[j]);
			}
			HashSet<long> claimedPreviousOwners = new HashSet<long>();
			foreach (List<MarkerSemanticCluster> value2 in dictionary.Values)
			{
				value2.Sort((MarkerSemanticCluster left, MarkerSemanticCluster right) => left.StableKey.CompareTo(right.StableKey));
				long[] memberKeys = CollectMemberKeys(value2);
				if (value2.Count < 2)
				{
					if (TryClaimPreviousOwnerKey(memberKeys, claimedPreviousOwners, out var ownerKey))
					{
						MarkerSemanticCluster presentationCluster = BuildSummaryCluster(ownerKey, value2, memberKeys);
						list.Add(new MarkerDenseAreaPresentationNode(ownerKey, isDenseSummary: true, new long[1] { value2[0].StableKey }, presentationCluster));
					}
					else
					{
						MarkerSemanticCluster markerSemanticCluster = value2[0];
						list.Add(new MarkerDenseAreaPresentationNode(markerSemanticCluster.StableKey, isDenseSummary: false, new long[1] { markerSemanticCluster.StableKey }, markerSemanticCluster));
					}
				}
				else
				{
					long num3 = ResolvePersistentOwnerKey(memberKeys, claimedPreviousOwners);
					MarkerSemanticCluster presentationCluster2 = BuildSummaryCluster(num3, value2, memberKeys);
					long[] array2 = new long[value2.Count];
					for (int num4 = 0; num4 < value2.Count; num4++)
					{
						array2[num4] = value2[num4].StableKey;
					}
					list.Add(new MarkerDenseAreaPresentationNode(num3, isDenseSummary: true, array2, presentationCluster2));
				}
			}
			list.Sort((MarkerDenseAreaPresentationNode left, MarkerDenseAreaPresentationNode right) => left.StableKey.CompareTo(right.StableKey));
			return list;
		}

		private long ResolvePersistentOwnerKey(long[] memberKeys, HashSet<long> claimedPreviousOwners)
		{
			if (TryClaimPreviousOwnerKey(memberKeys, claimedPreviousOwners, out var ownerKey))
			{
				return ownerKey;
			}
			long num = -MarkerWorldClusterTracker.StableClusterKey(memberKeys);
			if (num == 0L || num == long.MinValue)
			{
				num = -1L;
			}
			claimedPreviousOwners.Add(num);
			return num;
		}

		private bool TryClaimPreviousOwnerKey(long[] memberKeys, HashSet<long> claimedPreviousOwners, out long ownerKey)
		{
			long num = 0L;
			int num2 = 0;
			for (int i = 0; i < _previousDenseOwners.Count; i++)
			{
				PreviousDenseOwner previousDenseOwner = _previousDenseOwners[i];
				if (!claimedPreviousOwners.Contains(previousDenseOwner.OwnerKey))
				{
					int num3 = CountOverlap(previousDenseOwner.MemberKeys, memberKeys);
					if (num3 > num2 || (num3 == num2 && num3 > 0 && previousDenseOwner.OwnerKey < num))
					{
						num2 = num3;
						num = previousDenseOwner.OwnerKey;
					}
				}
			}
			if (num2 > 0)
			{
				claimedPreviousOwners.Add(num);
				ownerKey = num;
				return true;
			}
			ownerKey = 0L;
			return false;
		}

		private static MarkerSemanticCluster BuildSummaryCluster(long ownerKey, IReadOnlyList<MarkerSemanticCluster> clusters, long[] memberKeys)
		{
			Dictionary<MarkerSemanticCategory, int> dictionary = new Dictionary<MarkerSemanticCategory, int>();
			Dictionary<MarkerItemLifetimeKey, MutableAggregate> dictionary2 = new Dictionary<MarkerItemLifetimeKey, MutableAggregate>();
			double num = 0.0;
			double num2 = 0.0;
			double num3 = 0.0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			for (int i = 0; i < clusters.Count; i++)
			{
				MarkerSemanticCluster markerSemanticCluster = clusters[i];
				int num8 = Math.Max(1, markerSemanticCluster.TotalCount);
				num += (double)(markerSemanticCluster.WorldAnchor.X * (float)num8);
				num2 += (double)(markerSemanticCluster.WorldAnchor.Y * (float)num8);
				num3 += (double)(markerSemanticCluster.WorldAnchor.Z * (float)num8);
				num4 += num8;
				num5 += markerSemanticCluster.TemporaryPhysicalMemberCount;
				num6 += markerSemanticCluster.MixedLifetimeMemberCount;
				num7 += markerSemanticCluster.UnknownLifetimeMemberCount;
				for (int j = 0; j < markerSemanticCluster.Composition.Count; j++)
				{
					MarkerCategoryCount markerCategoryCount = markerSemanticCluster.Composition[j];
					dictionary.TryGetValue(markerCategoryCount.Category, out var value);
					dictionary[markerCategoryCount.Category] = value + markerCategoryCount.Count;
				}
				for (int k = 0; k < markerSemanticCluster.ItemRows.Count; k++)
				{
					MarkerItemAggregate markerItemAggregate = markerSemanticCluster.ItemRows[k];
					MarkerItemLifetimeKey key = new MarkerItemLifetimeKey(markerItemAggregate.ItemIdentity, markerItemAggregate.Lifetime);
					if (!dictionary2.TryGetValue(key, out var value2))
					{
						value2 = new MutableAggregate(markerItemAggregate.ItemIdentity, markerItemAggregate.LocalizedName, markerItemAggregate.Category, markerItemAggregate.Lifetime);
						dictionary2.Add(key, value2);
					}
					value2.Count += markerItemAggregate.Count;
				}
			}
			List<MarkerCategoryCount> list = new List<MarkerCategoryCount>(dictionary.Count);
			foreach (KeyValuePair<MarkerSemanticCategory, int> item in dictionary)
			{
				list.Add(new MarkerCategoryCount(item.Key, item.Value));
			}
			list.Sort((MarkerCategoryCount left, MarkerCategoryCount right) => MarkerSemanticCategoryPolicy.StableOrder(left.Category).CompareTo(MarkerSemanticCategoryPolicy.StableOrder(right.Category)));
			List<MarkerItemAggregate> list2 = new List<MarkerItemAggregate>(dictionary2.Count);
			foreach (MutableAggregate value3 in dictionary2.Values)
			{
				list2.Add(new MarkerItemAggregate(value3.ItemIdentity, value