#include "HyperTwistTraining/HyperTwistTrainingRepositoryLibrary.h"

#include "HyperTwistTraining/HyperTwistTrainingCatalogLibrary.h"
#include "HyperTwistTraining/HyperTwistTrainingKnowledgeLibrary.h"
#include "HyperTwistTraining/HyperTwistTrainingLibrary.h"
#include "JsonObjectConverter.h"

namespace HyperTwistTrainingRepositoryLibraryInternal
{
	constexpr double DefaultMinStabilityDays = 0.25;
	constexpr double DefaultDifficultyScore = 5.0;
	constexpr int32 ReviewBaselineSampleSize = 8;
	constexpr double MuchSlowerThreshold = 1.35;
	constexpr int32 AutoLearningMinReviews = 5;
	constexpr int32 AutoLearningWindow = 12;
	constexpr int32 AutoLearningMinSuccesses = 11;
	constexpr int32 UpwardGrowthThrottleMs = 2 * 60 * 1000;
	constexpr double MatureStabilityDays = 7.0;
	const TCHAR* CaseKeySeparator = TEXT("\x1f");

	EHyperTwistTrainingCoachGuidanceLane GuidanceLaneFromQueueEntry(
		const FHyperTwistTrainingCoachSessionQueueStateEntry* Entry
	);

	const FHyperTwistTrainingCoachSessionQueueStateEntry* FindQueueEntryById(
		const FHyperTwistTrainingCoachSessionQueueState& QueueState,
		const FString& EntryId
	);

	TArray<FHyperTwistTrainingRunRecord> SortRunRecordsByUpdateUtc(
		const TArray<FHyperTwistTrainingRunRecord>& RunRecords
	);

	struct FMethodSegmentAggregate
	{
		FHyperTwistTrainingMethodSegment Segment;
		TMap<FString, int32> FocusScoreByDeck;
		TMap<EHyperTwistTrainingDeliveryMode, int32> SessionCountByMode;
		int64 TotalTimeAccumulator = 0;
		int32 TotalTimeCount = 0;
		int64 RawTimeAccumulator = 0;
		int32 RawTimeCount = 0;
		TArray<FHyperTwistTrainingCaseLearnerState> CandidateStates;
	};

	int32 CompareUtcStrings(const FString& Left, const FString& Right)
	{
		return Left.Compare(Right, ESearchCase::CaseSensitive);
	}

	bool TryParseUtc(const FString& Value, FDateTime& OutDateTime)
	{
		return !Value.IsEmpty() && FDateTime::ParseIso8601(*Value, OutDateTime);
	}

	FString ResolveReferenceUtc(const FString& ReferenceUtc)
	{
		return ReferenceUtc.IsEmpty() ? FDateTime::UtcNow().ToIso8601() : ReferenceUtc;
	}

	TArray<FString> NormalizeNonEmptyUniqueStrings(const TArray<FString>& Values)
	{
		TArray<FString> Normalized;
		for (const FString& Value : Values)
		{
			if (!Value.IsEmpty())
			{
				Normalized.AddUnique(Value);
			}
		}

		Normalized.Sort();
		return Normalized;
	}

	FHyperTwistTrainingSmartDeviceIdentity NormalizeSmartDeviceIdentity(
		const FHyperTwistTrainingSmartDeviceIdentity& DeviceIdentity
	)
	{
		FHyperTwistTrainingSmartDeviceIdentity Normalized = DeviceIdentity;
		if (Normalized.DeviceName.IsEmpty())
		{
			Normalized.DeviceName = Normalized.DeviceId;
		}

		Normalized.CapabilityTags = NormalizeNonEmptyUniqueStrings(Normalized.CapabilityTags);
		return Normalized;
	}

	TArray<FHyperTwistTrainingSplitCapture> NormalizeSmartDeviceSplitCaptures(
		const TArray<FHyperTwistTrainingSplitCapture>& SplitCaptures
	)
	{
		TArray<FHyperTwistTrainingSplitCapture> Normalized;
		TSet<FString> SeenKeys;
		for (FHyperTwistTrainingSplitCapture SplitCapture : SplitCaptures)
		{
			if (!SplitCapture.IsStructurallyValid())
			{
				continue;
			}

			const FString SplitKey = !SplitCapture.PhaseId.IsEmpty()
				? SplitCapture.PhaseId
				: FString::Printf(TEXT("timestamp-%d"), SplitCapture.TimestampMs);
			if (SeenKeys.Contains(SplitKey))
			{
				continue;
			}

			SplitCapture.TimestampMs = FMath::Max(0, SplitCapture.TimestampMs);
			if (SplitCapture.Label.IsEmpty())
			{
				SplitCapture.Label = SplitCapture.PhaseId;
			}

			SeenKeys.Add(SplitKey);
			Normalized.Add(SplitCapture);
		}

		Normalized.Sort([](
			const FHyperTwistTrainingSplitCapture& Left,
			const FHyperTwistTrainingSplitCapture& Right
		)
		{
			if (Left.TimestampMs != Right.TimestampMs)
			{
				return Left.TimestampMs < Right.TimestampMs;
			}

			return Left.PhaseId < Right.PhaseId;
		});
		return Normalized;
	}

	FHyperTwistTrainingSmartDeviceEventFrame NormalizeSmartDeviceEventFrame(
		const FHyperTwistTrainingSmartDeviceEventFrame& EventFrame
	)
	{
		FHyperTwistTrainingSmartDeviceEventFrame Normalized = EventFrame;
		Normalized.DeviceIdentity = NormalizeSmartDeviceIdentity(Normalized.DeviceIdentity);
		if (Normalized.EventId.IsEmpty() && Normalized.SequenceNumber >= 0)
		{
			Normalized.EventId = FString::Printf(TEXT("sequence-%lld"), Normalized.SequenceNumber);
		}

		Normalized.OccurredAtUtc = ResolveReferenceUtc(Normalized.OccurredAtUtc);
		Normalized.TotalTimeMs = FMath::Max(0, Normalized.TotalTimeMs);
		Normalized.RawSolveTimeMs = FMath::Max(0, Normalized.RawSolveTimeMs);
		Normalized.InspectionElapsedMs = FMath::Max(0, Normalized.InspectionElapsedMs);
		Normalized.MistakeCount = FMath::Max(0, Normalized.MistakeCount);
		if (Normalized.RawSolveTimeMs == 0 && Normalized.TotalTimeMs > 0)
		{
			Normalized.RawSolveTimeMs = Normalized.TotalTimeMs;
		}

		Normalized.SplitCaptures = NormalizeSmartDeviceSplitCaptures(Normalized.SplitCaptures);
		return Normalized;
	}

	FHyperTwistTrainingSmartDeviceSessionRecord NormalizeSmartDeviceSessionRecord(
		const FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord
	)
	{
		FHyperTwistTrainingSmartDeviceSessionRecord Normalized = SessionRecord;
		Normalized.DeviceIdentity = NormalizeSmartDeviceIdentity(Normalized.DeviceIdentity);
		Normalized.AcceptedEventCount = FMath::Max(0, Normalized.AcceptedEventCount);
		Normalized.DuplicateEventCount = FMath::Max(0, Normalized.DuplicateEventCount);
		Normalized.LinkedAttemptIds = NormalizeNonEmptyUniqueStrings(Normalized.LinkedAttemptIds);
		if (!Normalized.LastLinkedAttemptId.IsEmpty())
		{
			Normalized.LinkedAttemptIds.AddUnique(Normalized.LastLinkedAttemptId);
			Normalized.LinkedAttemptIds.Sort();
		}

		Normalized.LinkedAttemptCount = Normalized.LinkedAttemptIds.Num();
		if (Normalized.LastUpdatedAtUtc.IsEmpty())
		{
			Normalized.LastUpdatedAtUtc = !Normalized.EndedAtUtc.IsEmpty()
				? Normalized.EndedAtUtc
				: Normalized.StartedAtUtc;
		}

		return Normalized;
	}

	FString BuildSmartDeviceEventKey(const FHyperTwistTrainingSmartDeviceEventFrame& EventFrame)
	{
		return EventFrame.BuildEventKey();
	}

	TArray<FHyperTwistTrainingSmartDeviceSessionRecord> SortSmartDeviceSessionsByUpdateUtc(
		const TArray<FHyperTwistTrainingSmartDeviceSessionRecord>& SessionRecords
	)
	{
		TArray<FHyperTwistTrainingSmartDeviceSessionRecord> Sorted = SessionRecords;
		Sorted.Sort([](
			const FHyperTwistTrainingSmartDeviceSessionRecord& Left,
			const FHyperTwistTrainingSmartDeviceSessionRecord& Right
		)
		{
			if (Left.UserId != Right.UserId)
			{
				return Left.UserId < Right.UserId;
			}

			const FString LeftSortUtc = !Left.LastUpdatedAtUtc.IsEmpty() ? Left.LastUpdatedAtUtc : Left.StartedAtUtc;
			const FString RightSortUtc = !Right.LastUpdatedAtUtc.IsEmpty() ? Right.LastUpdatedAtUtc : Right.StartedAtUtc;
			const int32 UtcCompare = CompareUtcStrings(LeftSortUtc, RightSortUtc);
			if (UtcCompare != 0)
			{
				return UtcCompare > 0;
			}

			return Left.DeviceSessionId < Right.DeviceSessionId;
		});
		return Sorted;
	}

	TArray<FHyperTwistTrainingSmartDeviceEventFrame> SortSmartDeviceEventFramesByOccurredAtUtc(
		const TArray<FHyperTwistTrainingSmartDeviceEventFrame>& EventFrames
	)
	{
		TArray<FHyperTwistTrainingSmartDeviceEventFrame> Sorted = EventFrames;
		Sorted.Sort([](
			const FHyperTwistTrainingSmartDeviceEventFrame& Left,
			const FHyperTwistTrainingSmartDeviceEventFrame& Right
		)
		{
			const int32 UtcCompare = CompareUtcStrings(Left.OccurredAtUtc, Right.OccurredAtUtc);
			if (UtcCompare != 0)
			{
				return UtcCompare < 0;
			}
			if (Left.SequenceNumber != Right.SequenceNumber)
			{
				return Left.SequenceNumber < Right.SequenceNumber;
			}

			return Left.EventId < Right.EventId;
		});
		return Sorted;
	}

	void SyncSmartDeviceSessionsFromEvents(
		TArray<FHyperTwistTrainingSmartDeviceSessionRecord>& SessionRecords,
		const TArray<FHyperTwistTrainingSmartDeviceEventFrame>& EventFrames
	)
	{
		TMap<FString, int32> SessionIndexById;
		for (int32 Index = 0; Index < SessionRecords.Num(); ++Index)
		{
			FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord = SessionRecords[Index];
			SessionRecord.AcceptedEventCount = 0;
			SessionRecord.LinkedAttemptIds.Reset();
			SessionRecord.LinkedAttemptCount = 0;
			SessionRecord.LastEventKey.Reset();
			SessionRecord.LastEventId.Reset();
			SessionRecord.LastEventKind = EHyperTwistTrainingSmartDeviceEventKind::None;
			SessionRecord.LastLinkedAttemptId.Reset();
			SessionIndexById.Add(SessionRecord.DeviceSessionId, Index);
		}

		for (const FHyperTwistTrainingSmartDeviceEventFrame& EventFrame : EventFrames)
		{
			const int32* SessionIndex = SessionIndexById.Find(EventFrame.DeviceSessionId);
			if (SessionIndex == nullptr || !SessionRecords.IsValidIndex(*SessionIndex))
			{
				continue;
			}

			FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord = SessionRecords[*SessionIndex];
			SessionRecord.AcceptedEventCount += 1;
			SessionRecord.LastSequenceNumber = FMath::Max(SessionRecord.LastSequenceNumber, EventFrame.SequenceNumber);

			if (!EventFrame.LinkedAttemptId.IsEmpty())
			{
				SessionRecord.LinkedAttemptIds.AddUnique(EventFrame.LinkedAttemptId);
				SessionRecord.LastLinkedAttemptId = EventFrame.LinkedAttemptId;
			}

			const bool bUseAsLastEvent = SessionRecord.LastUpdatedAtUtc.IsEmpty()
				|| CompareUtcStrings(EventFrame.OccurredAtUtc, SessionRecord.LastUpdatedAtUtc) >= 0;
			if (!bUseAsLastEvent)
			{
				continue;
			}

			SessionRecord.LastUpdatedAtUtc = EventFrame.OccurredAtUtc;
			SessionRecord.LastEventId = EventFrame.EventId;
			SessionRecord.LastEventKey = BuildSmartDeviceEventKey(EventFrame);
			SessionRecord.LastEventKind = EventFrame.EventKind;
			if (!EventFrame.CaseId.IsEmpty())
			{
				SessionRecord.CaseId = EventFrame.CaseId;
			}
			if (!EventFrame.StatusReason.IsEmpty())
			{
				SessionRecord.LastStatusReason = EventFrame.StatusReason;
			}

			switch (EventFrame.EventKind)
			{
			case EHyperTwistTrainingSmartDeviceEventKind::Connected:
				SessionRecord.ConnectionState = EHyperTwistTrainingSmartDeviceConnectionState::Connected;
				break;
			case EHyperTwistTrainingSmartDeviceEventKind::InspectionStarted:
			case EHyperTwistTrainingSmartDeviceEventKind::SolveStarted:
			case EHyperTwistTrainingSmartDeviceEventKind::SplitCaptured:
			case EHyperTwistTrainingSmartDeviceEventKind::AttemptFinished:
				SessionRecord.ConnectionState = EHyperTwistTrainingSmartDeviceConnectionState::Streaming;
				break;
			case EHyperTwistTrainingSmartDeviceEventKind::Disconnected:
				SessionRecord.ConnectionState = EHyperTwistTrainingSmartDeviceConnectionState::Disconnected;
				SessionRecord.EndedAtUtc = EventFrame.OccurredAtUtc;
				break;
			case EHyperTwistTrainingSmartDeviceEventKind::Faulted:
				SessionRecord.ConnectionState = EHyperTwistTrainingSmartDeviceConnectionState::Faulted;
				SessionRecord.EndedAtUtc = EventFrame.OccurredAtUtc;
				break;
			case EHyperTwistTrainingSmartDeviceEventKind::None:
			default:
				break;
			}
		}

		for (FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord : SessionRecords)
		{
			SessionRecord.LinkedAttemptIds = NormalizeNonEmptyUniqueStrings(SessionRecord.LinkedAttemptIds);
			SessionRecord.LinkedAttemptCount = SessionRecord.LinkedAttemptIds.Num();
		}
	}

	FString MakeFriendLinkKey(const FString& UserId, const FString& FriendUserId)
	{
		return FString::Printf(TEXT("%s%s%s"), *UserId, CaseKeySeparator, *FriendUserId);
	}

	FHyperTwistTrainingFriendIdentitySnapshot NormalizeFriendIdentitySnapshot(
		const FHyperTwistTrainingFriendIdentitySnapshot& Snapshot
	)
	{
		FHyperTwistTrainingFriendIdentitySnapshot Normalized = Snapshot;
		if (Normalized.DisplayName.IsEmpty())
		{
			Normalized.DisplayName = Normalized.FriendUserId;
		}
		if (Normalized.PublicationId.IsEmpty() && !Normalized.FriendUserId.IsEmpty() && !Normalized.DeckId.IsEmpty())
		{
			Normalized.PublicationId = FString::Printf(
				TEXT("publication/%s/%s"),
				*Normalized.FriendUserId,
				*Normalized.DeckId
			);
		}

		Normalized.Tags = NormalizeNonEmptyUniqueStrings(Normalized.Tags);
		return Normalized;
	}

	FHyperTwistTrainingFriendLinkRecord NormalizeFriendLinkRecord(
		const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord
	)
	{
		FHyperTwistTrainingFriendLinkRecord Normalized = FriendLinkRecord;
		Normalized.FriendSnapshot = NormalizeFriendIdentitySnapshot(Normalized.FriendSnapshot);
		Normalized.Tags = NormalizeNonEmptyUniqueStrings(Normalized.Tags);
		if (Normalized.LinkId.IsEmpty()
			&& !Normalized.UserId.IsEmpty()
			&& !Normalized.FriendSnapshot.FriendUserId.IsEmpty())
		{
			Normalized.LinkId = FString::Printf(
				TEXT("friend-link/%s/%s"),
				*Normalized.UserId,
				*Normalized.FriendSnapshot.FriendUserId
			);
		}
		if (Normalized.RequestedAtUtc.IsEmpty())
		{
			Normalized.RequestedAtUtc = ResolveReferenceUtc(Normalized.LastUpdatedAtUtc);
		}
		if ((Normalized.State == EHyperTwistTrainingFriendLinkState::Active
				|| Normalized.State == EHyperTwistTrainingFriendLinkState::Rejected)
			&& Normalized.RespondedAtUtc.IsEmpty())
		{
			Normalized.RespondedAtUtc = ResolveReferenceUtc(
				!Normalized.LastUpdatedAtUtc.IsEmpty() ? Normalized.LastUpdatedAtUtc : Normalized.RequestedAtUtc
			);
		}
		if (Normalized.LastUpdatedAtUtc.IsEmpty())
		{
			Normalized.LastUpdatedAtUtc = !Normalized.RespondedAtUtc.IsEmpty()
				? Normalized.RespondedAtUtc
				: Normalized.RequestedAtUtc;
		}
		return Normalized;
	}

	TArray<FHyperTwistTrainingFriendLinkRecord> SortFriendLinksByUpdateUtc(
		const TArray<FHyperTwistTrainingFriendLinkRecord>& FriendLinkRecords
	)
	{
		TArray<FHyperTwistTrainingFriendLinkRecord> Sorted = FriendLinkRecords;
		Sorted.Sort([](
			const FHyperTwistTrainingFriendLinkRecord& Left,
			const FHyperTwistTrainingFriendLinkRecord& Right
		)
		{
			if (Left.UserId != Right.UserId)
			{
				return Left.UserId < Right.UserId;
			}

			const int32 UtcCompare = CompareUtcStrings(Left.LastUpdatedAtUtc, Right.LastUpdatedAtUtc);
			if (UtcCompare != 0)
			{
				return UtcCompare > 0;
			}

			return Left.FriendSnapshot.FriendUserId < Right.FriendSnapshot.FriendUserId;
		});
		return Sorted;
	}

	FString ResolveNotificationTitle(const EHyperTwistTrainingNotificationKind Kind)
	{
		switch (Kind)
		{
		case EHyperTwistTrainingNotificationKind::FriendRequest:
			return TEXT("Friend request");
		case EHyperTwistTrainingNotificationKind::FriendAccepted:
			return TEXT("Friend request accepted");
		case EHyperTwistTrainingNotificationKind::FriendActivity:
			return TEXT("Friend activity");
		case EHyperTwistTrainingNotificationKind::ChallengeInvitation:
			return TEXT("Challenge invitation");
		case EHyperTwistTrainingNotificationKind::ChallengeAccepted:
			return TEXT("Challenge accepted");
		case EHyperTwistTrainingNotificationKind::ChallengeReady:
			return TEXT("Challenge ready");
		case EHyperTwistTrainingNotificationKind::ChallengeExpired:
			return TEXT("Challenge expired");
		case EHyperTwistTrainingNotificationKind::ChallengeCompleted:
			return TEXT("Challenge completed");
		case EHyperTwistTrainingNotificationKind::None:
		default:
			return TEXT("Notification");
		}
	}

	FString ResolveNotificationSortUtc(const FHyperTwistTrainingNotificationRecord& NotificationRecord)
	{
		if (!NotificationRecord.ArchivedAtUtc.IsEmpty())
		{
			return NotificationRecord.ArchivedAtUtc;
		}
		if (!NotificationRecord.AcknowledgedAtUtc.IsEmpty())
		{
			return NotificationRecord.AcknowledgedAtUtc;
		}
		if (!NotificationRecord.ReadAtUtc.IsEmpty())
		{
			return NotificationRecord.ReadAtUtc;
		}
		return NotificationRecord.CreatedAtUtc;
	}

	FHyperTwistTrainingNotificationRecord NormalizeNotificationRecord(
		const FHyperTwistTrainingNotificationRecord& NotificationRecord
	)
	{
		FHyperTwistTrainingNotificationRecord Normalized = NotificationRecord;
		Normalized.CreatedAtUtc = ResolveReferenceUtc(Normalized.CreatedAtUtc);
		if (Normalized.Title.IsEmpty())
		{
			Normalized.Title = ResolveNotificationTitle(Normalized.Kind);
		}
		if (Normalized.ArchivedAtUtc.IsEmpty()
			&& Normalized.VisibilityState == EHyperTwistTrainingNotificationVisibilityState::Archived)
		{
			Normalized.ArchivedAtUtc = ResolveReferenceUtc(
				!Normalized.AcknowledgedAtUtc.IsEmpty()
					? Normalized.AcknowledgedAtUtc
					: (!Normalized.ReadAtUtc.IsEmpty() ? Normalized.ReadAtUtc : Normalized.CreatedAtUtc)
			);
		}
		if (!Normalized.ArchivedAtUtc.IsEmpty())
		{
			Normalized.VisibilityState = EHyperTwistTrainingNotificationVisibilityState::Archived;
		}
		else if (Normalized.VisibilityState == EHyperTwistTrainingNotificationVisibilityState::None)
		{
			Normalized.VisibilityState = EHyperTwistTrainingNotificationVisibilityState::Inbox;
		}

		if (Normalized.bRead && Normalized.ReadAtUtc.IsEmpty())
		{
			Normalized.ReadAtUtc = ResolveReferenceUtc(Normalized.CreatedAtUtc);
		}
		if (Normalized.bAcknowledged && Normalized.AcknowledgedAtUtc.IsEmpty())
		{
			Normalized.AcknowledgedAtUtc = ResolveReferenceUtc(
				!Normalized.ReadAtUtc.IsEmpty() ? Normalized.ReadAtUtc : Normalized.CreatedAtUtc
			);
		}
		Normalized.bRead = Normalized.bRead || !Normalized.ReadAtUtc.IsEmpty();
		Normalized.bAcknowledged = Normalized.bAcknowledged || !Normalized.AcknowledgedAtUtc.IsEmpty();
		if (Normalized.VisibilityReason.IsEmpty())
		{
			Normalized.VisibilityReason =
				Normalized.VisibilityState == EHyperTwistTrainingNotificationVisibilityState::Archived
					? TEXT("archived")
					: (Normalized.VisibilityState == EHyperTwistTrainingNotificationVisibilityState::Inbox
						? TEXT("inbox")
						: TEXT("hidden"));
		}
		if (Normalized.SummaryLine.IsEmpty())
		{
			Normalized.SummaryLine = !Normalized.ChallengeId.IsEmpty()
				? FString::Printf(TEXT("Related challenge %s"), *Normalized.ChallengeId)
				: (!Normalized.FriendUserId.IsEmpty()
					? FString::Printf(TEXT("Related friend %s"), *Normalized.FriendUserId)
					: TEXT("Local social notification"));
		}
		return Normalized;
	}

	TArray<FHyperTwistTrainingNotificationRecord> SortNotificationsByChangeUtc(
		const TArray<FHyperTwistTrainingNotificationRecord>& NotificationRecords
	)
	{
		TArray<FHyperTwistTrainingNotificationRecord> Sorted = NotificationRecords;
		Sorted.Sort([](
			const FHyperTwistTrainingNotificationRecord& Left,
			const FHyperTwistTrainingNotificationRecord& Right
		)
		{
			if (Left.RecipientUserId != Right.RecipientUserId)
			{
				return Left.RecipientUserId < Right.RecipientUserId;
			}

			const int32 UtcCompare = CompareUtcStrings(
				ResolveNotificationSortUtc(Left),
				ResolveNotificationSortUtc(Right)
			);
			if (UtcCompare != 0)
			{
				return UtcCompare > 0;
			}

			return Left.NotificationId < Right.NotificationId;
		});
		return Sorted;
	}

	FHyperTwistTrainingChallengeParticipantSnapshot NormalizeChallengeParticipantSnapshot(
		const FHyperTwistTrainingChallengeParticipantSnapshot& Snapshot,
		const FString& DefaultDeckId
	)
	{
		FHyperTwistTrainingChallengeParticipantSnapshot Normalized = Snapshot;
		if (Normalized.DisplayName.IsEmpty())
		{
			Normalized.DisplayName = Normalized.UserId;
		}
		if (Normalized.DeckId.IsEmpty())
		{
			Normalized.DeckId = DefaultDeckId;
		}
		if (!Normalized.ReferenceEntry.IsStructurallyValid() && !Normalized.UserId.IsEmpty())
		{
			Normalized.ReferenceEntry.EntryId = FString::Printf(
				TEXT("challenge-entry/%s"),
				*Normalized.UserId
			);
		}
		if (Normalized.ReferenceEntry.SolverDisplayName.IsEmpty())
		{
			Normalized.ReferenceEntry.SolverDisplayName = Normalized.DisplayName;
		}
		if (Normalized.ReferenceEntry.DeckId.IsEmpty())
		{
			Normalized.ReferenceEntry.DeckId = Normalized.DeckId;
		}
		return Normalized;
	}

	EHyperTwistTrainingLocalMatchReadinessState ResolveChallengeReadinessByLifecycle(
		const EHyperTwistTrainingChallengeLifecycleState LifecycleState,
		const EHyperTwistTrainingLocalMatchReadinessState MatchReadinessState
	)
	{
		if (MatchReadinessState != EHyperTwistTrainingLocalMatchReadinessState::None)
		{
			return MatchReadinessState;
		}

		switch (LifecycleState)
		{
		case EHyperTwistTrainingChallengeLifecycleState::Pending:
			return EHyperTwistTrainingLocalMatchReadinessState::Seeded;
		case EHyperTwistTrainingChallengeLifecycleState::Accepted:
			return EHyperTwistTrainingLocalMatchReadinessState::AwaitingAttempts;
		case EHyperTwistTrainingChallengeLifecycleState::Ready:
			return EHyperTwistTrainingLocalMatchReadinessState::ReadyToCompare;
		case EHyperTwistTrainingChallengeLifecycleState::Completed:
			return EHyperTwistTrainingLocalMatchReadinessState::ComparisonLocked;
		case EHyperTwistTrainingChallengeLifecycleState::Rejected:
		case EHyperTwistTrainingChallengeLifecycleState::Expired:
		case EHyperTwistTrainingChallengeLifecycleState::None:
		default:
			return EHyperTwistTrainingLocalMatchReadinessState::None;
		}
	}

	FHyperTwistTrainingChallengeRecord NormalizeChallengeRecord(
		const FHyperTwistTrainingChallengeRecord& ChallengeRecord
	)
	{
		FHyperTwistTrainingChallengeRecord Normalized = ChallengeRecord;
		Normalized.ChallengerSnapshot = NormalizeChallengeParticipantSnapshot(
			Normalized.ChallengerSnapshot,
			Normalized.DeckId
		);
		Normalized.RecipientSnapshot = NormalizeChallengeParticipantSnapshot(
			Normalized.RecipientSnapshot,
			Normalized.DeckId
		);
		if (Normalized.EventId.IsEmpty())
		{
			if (!Normalized.ChallengerSnapshot.ReferenceEntry.EventId.IsEmpty())
			{
				Normalized.EventId = Normalized.ChallengerSnapshot.ReferenceEntry.EventId;
			}
			else if (!Normalized.RecipientSnapshot.ReferenceEntry.EventId.IsEmpty())
			{
				Normalized.EventId = Normalized.RecipientSnapshot.ReferenceEntry.EventId;
			}
		}
		if (Normalized.DeckId.IsEmpty())
		{
			Normalized.DeckId = !Normalized.ChallengerSnapshot.DeckId.IsEmpty()
				? Normalized.ChallengerSnapshot.DeckId
				: Normalized.RecipientSnapshot.DeckId;
		}
		if (Normalized.ChallengerSnapshot.ReferenceEntry.EventId.IsEmpty())
		{
			Normalized.ChallengerSnapshot.ReferenceEntry.EventId = Normalized.EventId;
		}
		if (Normalized.RecipientSnapshot.ReferenceEntry.EventId.IsEmpty())
		{
			Normalized.RecipientSnapshot.ReferenceEntry.EventId = Normalized.EventId;
		}
		if (Normalized.ChallengerSnapshot.ReferenceEntry.DeckId.IsEmpty())
		{
			Normalized.ChallengerSnapshot.ReferenceEntry.DeckId = Normalized.DeckId;
		}
		if (Normalized.RecipientSnapshot.ReferenceEntry.DeckId.IsEmpty())
		{
			Normalized.RecipientSnapshot.ReferenceEntry.DeckId = Normalized.DeckId;
		}
		Normalized.CreatedAtUtc = ResolveReferenceUtc(Normalized.CreatedAtUtc);
		if ((Normalized.LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Accepted
				|| Normalized.LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Rejected)
			&& Normalized.RespondedAtUtc.IsEmpty())
		{
			Normalized.RespondedAtUtc = ResolveReferenceUtc(
				!Normalized.LastUpdatedAtUtc.IsEmpty() ? Normalized.LastUpdatedAtUtc : Normalized.CreatedAtUtc
			);
		}
		if (Normalized.LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Ready
			&& Normalized.ReadyAtUtc.IsEmpty())
		{
			Normalized.ReadyAtUtc = ResolveReferenceUtc(
				!Normalized.RespondedAtUtc.IsEmpty() ? Normalized.RespondedAtUtc : Normalized.CreatedAtUtc
			);
		}
		if (Normalized.LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Completed
			&& Normalized.CompletedAtUtc.IsEmpty())
		{
			Normalized.CompletedAtUtc = ResolveReferenceUtc(
				!Normalized.ReadyAtUtc.IsEmpty() ? Normalized.ReadyAtUtc : Normalized.CreatedAtUtc
			);
		}
		if (Normalized.LastUpdatedAtUtc.IsEmpty())
		{
			if (!Normalized.CompletedAtUtc.IsEmpty())
			{
				Normalized.LastUpdatedAtUtc = Normalized.CompletedAtUtc;
			}
			else if (!Normalized.ReadyAtUtc.IsEmpty())
			{
				Normalized.LastUpdatedAtUtc = Normalized.ReadyAtUtc;
			}
			else if (!Normalized.RespondedAtUtc.IsEmpty())
			{
				Normalized.LastUpdatedAtUtc = Normalized.RespondedAtUtc;
			}
			else
			{
				Normalized.LastUpdatedAtUtc = Normalized.CreatedAtUtc;
			}
		}
		if (Normalized.Title.IsEmpty())
		{
			Normalized.Title = FString::Printf(
				TEXT("%s vs %s"),
				Normalized.ChallengerSnapshot.DisplayName.IsEmpty()
					? *Normalized.ChallengerUserId
					: *Normalized.ChallengerSnapshot.DisplayName,
				Normalized.RecipientSnapshot.DisplayName.IsEmpty()
					? *Normalized.RecipientUserId
					: *Normalized.RecipientSnapshot.DisplayName
			);
		}
		if (Normalized.SummaryLine.IsEmpty())
		{
			Normalized.SummaryLine = !Normalized.EventId.IsEmpty()
				? FString::Printf(TEXT("Compare local results against %s"), *Normalized.EventId)
				: TEXT("Compare local challenge results");
		}
		Normalized.MatchReadinessState = ResolveChallengeReadinessByLifecycle(
			Normalized.LifecycleState,
			Normalized.MatchReadinessState
		);
		return Normalized;
	}

	TArray<FHyperTwistTrainingChallengeRecord> SortChallengesByUpdateUtc(
		const TArray<FHyperTwistTrainingChallengeRecord>& ChallengeRecords
	)
	{
		TArray<FHyperTwistTrainingChallengeRecord> Sorted = ChallengeRecords;
		Sorted.Sort([](
			const FHyperTwistTrainingChallengeRecord& Left,
			const FHyperTwistTrainingChallengeRecord& Right
		)
		{
			const FString LeftUserKey = Left.ChallengerUserId < Left.RecipientUserId
				? FString::Printf(TEXT("%s:%s"), *Left.ChallengerUserId, *Left.RecipientUserId)
				: FString::Printf(TEXT("%s:%s"), *Left.RecipientUserId, *Left.ChallengerUserId);
			const FString RightUserKey = Right.ChallengerUserId < Right.RecipientUserId
				? FString::Printf(TEXT("%s:%s"), *Right.ChallengerUserId, *Right.RecipientUserId)
				: FString::Printf(TEXT("%s:%s"), *Right.RecipientUserId, *Right.ChallengerUserId);
			if (LeftUserKey != RightUserKey)
			{
				return LeftUserKey < RightUserKey;
			}

			const int32 UtcCompare = CompareUtcStrings(Left.LastUpdatedAtUtc, Right.LastUpdatedAtUtc);
			if (UtcCompare != 0)
			{
				return UtcCompare > 0;
			}

			return Left.ChallengeId < Right.ChallengeId;
		});
		return Sorted;
	}

	FString FormatChallengeLifecycleLabel(const EHyperTwistTrainingChallengeLifecycleState LifecycleState)
	{
		if (const UEnum* Enum = StaticEnum<EHyperTwistTrainingChallengeLifecycleState>())
		{
			return Enum->GetNameStringByValue(static_cast<int64>(LifecycleState));
		}
		return TEXT("None");
	}

	FString FormatChallengeReadinessLabel(const EHyperTwistTrainingLocalMatchReadinessState MatchReadinessState)
	{
		if (const UEnum* Enum = StaticEnum<EHyperTwistTrainingLocalMatchReadinessState>())
		{
			return Enum->GetNameStringByValue(static_cast<int64>(MatchReadinessState));
		}
		return TEXT("None");
	}

	bool IsActiveChallenge(const FHyperTwistTrainingChallengeRecord& ChallengeRecord)
	{
		return ChallengeRecord.LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Pending
			|| ChallengeRecord.LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Accepted
			|| ChallengeRecord.LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Ready;
	}

	bool IsReadyChallenge(const FHyperTwistTrainingChallengeRecord& ChallengeRecord)
	{
		return ChallengeRecord.MatchReadinessState
				== EHyperTwistTrainingLocalMatchReadinessState::ReadyToCompare
			|| ChallengeRecord.MatchReadinessState
				== EHyperTwistTrainingLocalMatchReadinessState::ComparisonLocked;
	}

	bool IsDeferredOverflowDashboardOutcomeSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-queued")
			|| SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-follow-up")
			|| SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-recommended");
	}

	bool IsDeferredFirstDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-deferred-first-queued")
			|| SourceLabel == TEXT("dashboard-handoff-deferred-first-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-deferred-first-recommended")
			|| SourceLabel.StartsWith(TEXT("coach-memory-dashboard-deferred-first-"));
	}

	bool IsMethodDrillDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-recommended")
			|| SourceLabel.StartsWith(TEXT("coach-memory-dashboard-method-drill-"));
	}

	bool IsAlignedTightFollowUpPacketDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-queued")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-recommended");
	}

	bool IsAlignedBroadRecommendedPacketDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-recommended");
	}

	bool IsStrongMethodDrillRecoveryDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-recommended");
	}

	bool IsStrongMethodDrillRecoveryPacketDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-recommended");
	}

	bool IsStrongMethodDrillFollowUpPacketDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-recommended");
	}

	bool IsWeakMethodDrillRecoveryDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-recommended");
	}

	bool IsNarrowMethodDrillRecoveryStructureDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-recommended");
	}

	bool IsBroadMethodDrillRecoveryStructureDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-broad-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-broad-recommended");
	}

	bool IsTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-recommended");
	}

	bool IsBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-recommended");
	}

	bool IsTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-recommended");
	}

	bool IsTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-recommended");
	}

	bool IsReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-recommended");
	}

	bool IsReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended");
	}

	bool IsReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-recommended");
	}

	bool IsReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-queued")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-follow-up")
			|| SourceLabel
				== TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended");
	}

	bool IsReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCoachMemorySource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned")
			|| SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome")
			|| SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-"));
	}

	bool IsReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCoachMemorySource(
		const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned")
			|| SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome")
			|| SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-"));
	}

	bool IsWeakMethodDrillRecoveryPacketDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-recommended");
	}

	bool IsWeakMethodDrillFollowUpPacketDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-recommended");
	}

	bool IsNarrowMethodDrillFollowUpPacketStructureCoachMemorySource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("coach-memory-method-drill-follow-up-packet-structure-narrow");
	}

	bool IsBroadMethodDrillFollowUpPacketStructureCoachMemorySource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("coach-memory-method-drill-follow-up-packet-structure-broad");
	}

	bool IsAlignedTightFollowUpPacketStructureCoachMemorySource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("coach-memory-aligned-follow-up-packet-structure-tight-follow-up");
	}

	bool IsAlignedBroadRecommendedPacketStructureCoachMemorySource(const FString& SourceLabel)
	{
		return SourceLabel
			== TEXT("coach-memory-aligned-follow-up-packet-structure-broad-recommended");
	}

	bool IsAcceptedAlignedTightFollowUpPacketOutcomeSource(const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-outcome")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel.StartsWith(TEXT("coach-memory-dashboard-aligned-follow-up-packet-tight-"))
			|| SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-"))
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-queued")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-recommended")
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-"));
	}

	bool IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(const FString& SourceLabel)
	{
		return SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-outcome")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
			|| SourceLabel.StartsWith(TEXT("coach-memory-dashboard-aligned-follow-up-packet-broad-"))
			|| SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-"))
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-recommended")
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-"));
	}

	bool IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-"));
	}

	bool IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-"));
	}

	bool IsReliableAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-reliable-"));
	}

	bool IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-reliable-outcome-"));
	}

	bool IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-reliable-"));
	}

	bool IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-reliable-outcome-"));
	}

	bool IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-"));
	}

	bool IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-"));
	}

	bool IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-"));
	}

	bool IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-"));
	}

	bool IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-reliable-"));
	}

	bool IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-reliable-"));
	}

	bool IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-reliable-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-reliable-reliable-"));
	}

	bool IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
		const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-reliable-reliable-"))
			|| SourceLabel.StartsWith(
				TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-reliable-reliable-"));
	}

	FString ResolveMethodDrillFollowUpPacketStructureRecoverySourceLabel(
		const FString& PreferredCoachHandoffSourceLabel,
		const FString& PreferredGuidanceSourceLabel)
	{
		if (IsNarrowMethodDrillFollowUpPacketStructureCoachMemorySource(
				PreferredCoachHandoffSourceLabel)
			|| IsBroadMethodDrillFollowUpPacketStructureCoachMemorySource(
				PreferredCoachHandoffSourceLabel))
		{
			return PreferredCoachHandoffSourceLabel;
		}

		if (IsNarrowMethodDrillFollowUpPacketStructureCoachMemorySource(
				PreferredGuidanceSourceLabel)
			|| IsBroadMethodDrillFollowUpPacketStructureCoachMemorySource(
				PreferredGuidanceSourceLabel))
		{
			return PreferredGuidanceSourceLabel;
		}

		return FString();
	}

	bool IsStrongRetainedMethodDrillRecoveryPostureDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-recommended");
	}

	bool IsWeakRetainedMethodDrillRecoveryPostureDashboardHandoffSource(
		const FString& SourceLabel)
	{
		return SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-recommended");
	}

	bool IsMethodDrillRecoveryCoachMemorySource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("coach-memory-method-drill-recovery-strong")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-weak")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-packet-strong")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-packet-weak")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-memory-strong")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-memory-weak")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-posture-strong")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-posture-weak")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-narrow")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-broad")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-plan-tight")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable")
			|| SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned")
			|| SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-plan-broad")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable")
			|| SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned")
			|| SourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome")
			|| SourceLabel.StartsWith(TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-"))
			|| SourceLabel.StartsWith(TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-broad-"));
	}

	bool IsStrongMethodDrillRecoveryPacketCoachMemorySource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-queued")
			|| SourceLabel
				== TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-follow-up")
			|| SourceLabel
				== TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-recommended")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-packet-strong");
	}

	bool IsWeakMethodDrillRecoveryPacketCoachMemorySource(const FString& SourceLabel)
	{
		return SourceLabel == TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-queued")
			|| SourceLabel
				== TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-follow-up")
			|| SourceLabel
				== TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-recommended")
			|| SourceLabel == TEXT("coach-memory-method-drill-recovery-packet-weak");
	}

	EHyperTwistTrainingCoachHandoffKind DashboardHandoffKindFromSourceLabel(const FString& SourceLabel)
	{
		if (SourceLabel == TEXT("dashboard-handoff-queued")
			|| SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-queued")
			|| SourceLabel == TEXT("dashboard-handoff-deferred-first-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-queued")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-queued")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-queued")
			|| (SourceLabel.StartsWith(
					TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-"))
				&& SourceLabel.EndsWith(TEXT("-queued")))
			|| (SourceLabel.StartsWith(
					TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-"))
				&& SourceLabel.EndsWith(TEXT("-queued")))
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-queued")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-queued"))
		{
			return EHyperTwistTrainingCoachHandoffKind::Queue;
		}
		if (SourceLabel == TEXT("dashboard-handoff-follow-up")
			|| SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-deferred-first-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-follow-up")
			|| (SourceLabel.StartsWith(
					TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-"))
				&& SourceLabel.EndsWith(TEXT("-follow-up")))
			|| (SourceLabel.StartsWith(
					TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-"))
				&& SourceLabel.EndsWith(TEXT("-follow-up")))
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-follow-up")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-follow-up"))
		{
			return EHyperTwistTrainingCoachHandoffKind::FollowUp;
		}
		if (SourceLabel == TEXT("dashboard-handoff-recommended")
			|| SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-deferred-first-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-follow-up-packet-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-narrow-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-reliable-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-tight-trusted-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-broad-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-structure-plan-broad-trusted-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-packet-weak-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-tight-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-aligned-follow-up-packet-broad-recommended")
			|| (SourceLabel.StartsWith(
					TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-tight-"))
				&& SourceLabel.EndsWith(TEXT("-recommended")))
			|| (SourceLabel.StartsWith(
					TEXT("dashboard-handoff-accepted-aligned-follow-up-packet-broad-"))
				&& SourceLabel.EndsWith(TEXT("-recommended")))
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-strong-recommended")
			|| SourceLabel == TEXT("dashboard-handoff-method-drill-recovery-posture-weak-recommended"))
		{
			return EHyperTwistTrainingCoachHandoffKind::Recommended;
		}

		return EHyperTwistTrainingCoachHandoffKind::None;
	}

	FString CoachMemoryDashboardSourceLabelFromDashboardStartSource(const FString& SourceLabel)
	{
		if (SourceLabel.StartsWith(TEXT("coach-memory-dashboard-")))
		{
			return SourceLabel;
		}
		if (SourceLabel.StartsWith(TEXT("dashboard-handoff-")))
		{
			return FString(TEXT("coach-memory-dashboard-"))
				+ SourceLabel.RightChop(FString(TEXT("dashboard-handoff-")).Len());
		}
		if (SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-queued"))
		{
			return TEXT("coach-memory-dashboard-deferred-overflow-queued");
		}
		if (SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-follow-up"))
		{
			return TEXT("coach-memory-dashboard-deferred-overflow-follow-up");
		}
		if (SourceLabel == TEXT("dashboard-guidance-outcome-deferred-overflow-recommended"))
		{
			return TEXT("coach-memory-dashboard-deferred-overflow-recommended");
		}
		return FString();
	}

	enum class EMethodDrillRecoveryMemoryBias : uint8
	{
		None,
		Strong,
		Weak
	};

	FString CoachMemoryDashboardSourceLabel(
		const EHyperTwistTrainingCoachHandoffKind HandoffKind,
		const bool bDeferredOverflowDriven,
		const bool bDeferredFirstDriven = false,
		const bool bMethodDrillDriven = false,
		const EMethodDrillRecoveryMemoryBias MethodDrillRecoveryMemoryBias =
			EMethodDrillRecoveryMemoryBias::None,
		const bool bRetainedMethodDrillRecoveryPostureDriven = false
	)
	{
		switch (HandoffKind)
		{
		case EHyperTwistTrainingCoachHandoffKind::Queue:
			if (bMethodDrillDriven)
			{
				if (MethodDrillRecoveryMemoryBias
					== EMethodDrillRecoveryMemoryBias::Strong)
				{
					if (bRetainedMethodDrillRecoveryPostureDriven)
					{
						return TEXT("coach-memory-dashboard-method-drill-recovery-posture-strong-queued");
					}
					return TEXT("coach-memory-dashboard-method-drill-recovery-strong-queued");
				}
				if (MethodDrillRecoveryMemoryBias
					== EMethodDrillRecoveryMemoryBias::Weak)
				{
					if (bRetainedMethodDrillRecoveryPostureDriven)
					{
						return TEXT("coach-memory-dashboard-method-drill-recovery-posture-weak-queued");
					}
					return TEXT("coach-memory-dashboard-method-drill-recovery-weak-queued");
				}
				return TEXT("coach-memory-dashboard-method-drill-queued");
			}
			if (bDeferredFirstDriven)
			{
				return TEXT("coach-memory-dashboard-deferred-first-queued");
			}
			return bDeferredOverflowDriven
				? TEXT("coach-memory-dashboard-deferred-overflow-queued")
				: TEXT("coach-memory-dashboard-queued");
		case EHyperTwistTrainingCoachHandoffKind::FollowUp:
			if (bMethodDrillDriven)
			{
				if (MethodDrillRecoveryMemoryBias
					== EMethodDrillRecoveryMemoryBias::Strong)
				{
					if (bRetainedMethodDrillRecoveryPostureDriven)
					{
						return TEXT("coach-memory-dashboard-method-drill-recovery-posture-strong-follow-up");
					}
					return TEXT("coach-memory-dashboard-method-drill-recovery-strong-follow-up");
				}
				if (MethodDrillRecoveryMemoryBias
					== EMethodDrillRecoveryMemoryBias::Weak)
				{
					if (bRetainedMethodDrillRecoveryPostureDriven)
					{
						return TEXT("coach-memory-dashboard-method-drill-recovery-posture-weak-follow-up");
					}
					return TEXT("coach-memory-dashboard-method-drill-recovery-weak-follow-up");
				}
				return TEXT("coach-memory-dashboard-method-drill-follow-up");
			}
			if (bDeferredFirstDriven)
			{
				return TEXT("coach-memory-dashboard-deferred-first-follow-up");
			}
			return bDeferredOverflowDriven
				? TEXT("coach-memory-dashboard-deferred-overflow-follow-up")
				: TEXT("coach-memory-dashboard-follow-up");
		case EHyperTwistTrainingCoachHandoffKind::Recommended:
			if (bMethodDrillDriven)
			{
				if (MethodDrillRecoveryMemoryBias
					== EMethodDrillRecoveryMemoryBias::Strong)
				{
					if (bRetainedMethodDrillRecoveryPostureDriven)
					{
						return TEXT("coach-memory-dashboard-method-drill-recovery-posture-strong-recommended");
					}
					return TEXT("coach-memory-dashboard-method-drill-recovery-strong-recommended");
				}
				if (MethodDrillRecoveryMemoryBias
					== EMethodDrillRecoveryMemoryBias::Weak)
				{
					if (bRetainedMethodDrillRecoveryPostureDriven)
					{
						return TEXT("coach-memory-dashboard-method-drill-recovery-posture-weak-recommended");
					}
					return TEXT("coach-memory-dashboard-method-drill-recovery-weak-recommended");
				}
				return TEXT("coach-memory-dashboard-method-drill-recommended");
			}
			if (bDeferredFirstDriven)
			{
				return TEXT("coach-memory-dashboard-deferred-first-recommended");
			}
			return bDeferredOverflowDriven
				? TEXT("coach-memory-dashboard-deferred-overflow-recommended")
				: TEXT("coach-memory-dashboard-recommended");
		default:
			return FString();
		}
	}

	FString AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
		const EHyperTwistTrainingCoachHandoffKind HandoffKind,
		const bool bTightFollowUpOutcomeTrust,
		const bool bReliableOutcomeTrust = false)
	{
		switch (HandoffKind)
		{
		case EHyperTwistTrainingCoachHandoffKind::Queue:
			if (bTightFollowUpOutcomeTrust)
			{
				return bReliableOutcomeTrust
					? TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-queued")
					: TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-queued");
			}
			return bReliableOutcomeTrust
				? TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-queued")
				: TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-queued");
		case EHyperTwistTrainingCoachHandoffKind::FollowUp:
			if (bTightFollowUpOutcomeTrust)
			{
				return bReliableOutcomeTrust
					? TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-follow-up")
					: TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-follow-up");
			}
			return bReliableOutcomeTrust
				? TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-follow-up")
				: TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-follow-up");
		case EHyperTwistTrainingCoachHandoffKind::Recommended:
			if (bTightFollowUpOutcomeTrust)
			{
				return bReliableOutcomeTrust
					? TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-recommended")
					: TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-recommended");
			}
			return bReliableOutcomeTrust
				? TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-recommended")
				: TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-recommended");
		default:
			return FString();
		}
	}

	bool IsDeferredOverflowDashboardHandoffSource(const FString& SourceLabel)
	{
		return SourceLabel.StartsWith(TEXT("coach-memory-dashboard-deferred-overflow-"))
			|| SourceLabel.StartsWith(TEXT("coach-memory-dashboard-deferred-first-"))
			|| SourceLabel == TEXT("recommendation-history-deferred-first-follow-up");
	}

	bool IsDeferredFirstFollowUpPacket(const FHyperTwistTrainingCoachActionPlan& ActionPlan)
	{
		if (ActionPlan.FollowUpDepth <= 0
			|| ActionPlan.DeferredLaunchCaseIds.Num() <= 0
			|| ActionPlan.FocusCaseIds.Num() <= 0)
		{
			return false;
		}

		TSet<FString> DeferredLaunchCaseSet;
		for (const FString& CaseId : ActionPlan.DeferredLaunchCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				DeferredLaunchCaseSet.Add(CaseId);
			}
		}

		if (DeferredLaunchCaseSet.Num() <= 0)
		{
			return false;
		}

		int32 DeferredPrefixCount = 0;
		for (const FString& CaseId : ActionPlan.FocusCaseIds)
		{
			if (DeferredLaunchCaseSet.Contains(CaseId))
			{
				DeferredPrefixCount += 1;
				continue;
			}

			break;
		}

		return DeferredPrefixCount > 0
			&& DeferredPrefixCount == FMath::Min(DeferredLaunchCaseSet.Num(), ActionPlan.FocusCaseIds.Num());
	}

	bool IsMethodDrillFollowUpTrainingSessionId(const FString& TrainingSessionId)
	{
		return !TrainingSessionId.IsEmpty()
			&& TrainingSessionId.Contains(TEXT("method_drill_follow_up"), ESearchCase::IgnoreCase);
	}

	bool IsCoachFollowUpTrainingSessionId(const FString& TrainingSessionId)
	{
		return !TrainingSessionId.IsEmpty()
			&& TrainingSessionId.Contains(TEXT("follow_up"), ESearchCase::IgnoreCase)
			&& !TrainingSessionId.Contains(TEXT("method_drill_follow_up"), ESearchCase::IgnoreCase);
	}

	bool IsNarrowMethodDrillFollowUpPacketStructureSessionId(const FString& TrainingSessionId)
	{
		return !TrainingSessionId.IsEmpty()
			&& TrainingSessionId.Contains(TEXT("__packet_narrow_"), ESearchCase::IgnoreCase);
	}

	bool IsBroadMethodDrillFollowUpPacketStructureSessionId(const FString& TrainingSessionId)
	{
		return !TrainingSessionId.IsEmpty()
			&& TrainingSessionId.Contains(TEXT("__packet_broad_"), ESearchCase::IgnoreCase);
	}

	bool IsAlignedTightCoachFollowUpPacketStructureSessionId(const FString& TrainingSessionId)
	{
		return !TrainingSessionId.IsEmpty()
			&& TrainingSessionId.Contains(
				TEXT("__aligned_packet_tight_follow_up"),
				ESearchCase::IgnoreCase
			);
	}

	bool IsAlignedBroadCoachFollowUpPacketStructureSessionId(const FString& TrainingSessionId)
	{
		return !TrainingSessionId.IsEmpty()
			&& TrainingSessionId.Contains(
				TEXT("__aligned_packet_broad_recommended"),
				ESearchCase::IgnoreCase
			);
	}

	float ResolveMethodDrillFollowUpOutcomeScore(const FHyperTwistTrainingRunRecord& RunRecord)
	{
		if (!RunRecord.IsStructurallyValid())
		{
			return 0.0f;
		}

		const FHyperTwistTrainingSessionSummary& Summary = RunRecord.Summary;
		if (Summary.CompletedAttemptCount <= 0)
		{
			return Summary.SessionState == EHyperTwistTrainingSessionState::Completed ? 15.0f : 0.0f;
		}

		const float SuccessPressure = FMath::Clamp(Summary.SuccessRate * 100.0f, 0.0f, 100.0f);
		const float MistakePenalty = FMath::Min(static_cast<float>(Summary.TotalMistakes) * 4.0f, 18.0f);
		const float FailurePenalty = static_cast<float>(Summary.FailureCount) * 6.0f;
		const float TimeoutPenalty = static_cast<float>(Summary.TimeoutCount) * 8.0f;
		const float DnfPenalty = static_cast<float>(Summary.DNFCount) * 10.0f;
		const float AbortPenalty = static_cast<float>(Summary.AbortedCount) * 9.0f;
		const float CompletionCredit = FMath::Min(static_cast<float>(Summary.CompletedAttemptCount) * 1.5f, 6.0f);
		return FMath::Clamp(
			SuccessPressure
				- MistakePenalty
				- FailurePenalty
				- TimeoutPenalty
				- DnfPenalty
				- AbortPenalty
				+ CompletionCredit,
			0.0f,
			100.0f
		);
	}

	float ResolveCoachFollowUpOutcomeScore(const FHyperTwistTrainingRunRecord& RunRecord)
	{
		return ResolveMethodDrillFollowUpOutcomeScore(RunRecord);
	}

	TArray<FString> DeduplicateTemplateCaseIds(const TArray<FString>& FocusCaseIds)
	{
		TArray<FString> UniqueCaseIds;
		for (const FString& CaseId : FocusCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				UniqueCaseIds.AddUnique(CaseId);
			}
		}

		return UniqueCaseIds;
	}

	FHyperTwistTrainingSessionTemplate NormalizeStoredTemplate(
		const FHyperTwistTrainingSessionTemplate& SessionTemplate
	)
	{
		FHyperTwistTrainingSessionTemplate NormalizedTemplate = SessionTemplate;
		NormalizedTemplate.FocusCaseIds = DeduplicateTemplateCaseIds(SessionTemplate.FocusCaseIds);
		NormalizedTemplate.RecommendedCaseCount = FMath::Max(
			1,
			NormalizedTemplate.RecommendedCaseCount > 0
				? NormalizedTemplate.RecommendedCaseCount
				: NormalizedTemplate.FocusCaseIds.Num()
		);
		NormalizedTemplate.bUserEditable = true;
		if (!NormalizedTemplate.bUserCreated)
		{
			if (NormalizedTemplate.SourceTemplateId.IsEmpty())
			{
				NormalizedTemplate.SourceTemplateId = NormalizedTemplate.TemplateId;
			}
			NormalizedTemplate.bUserCustomized = true;
		}
		if (NormalizedTemplate.LastUpdatedAtUtc.IsEmpty())
		{
			NormalizedTemplate.LastUpdatedAtUtc = FDateTime::UtcNow().ToIso8601();
		}

		return NormalizedTemplate;
	}

	FHyperTwistTrainingMethodDescriptor DescribeDeckMethodOrFallback(
		const TArray<FHyperTwistContentPack>& TrainingCatalog,
		const FString& DeckId
	)
	{
		FHyperTwistTrainingMethodDescriptor Descriptor;
		if (UHyperTwistTrainingCatalogLibrary::TryDescribeDeckMethodFromCatalog(TrainingCatalog, DeckId, Descriptor))
		{
			return Descriptor;
		}

		Descriptor.PuzzleId = TEXT("unknown");
		Descriptor.MethodKey = DeckId.ToLower();
		Descriptor.MethodLabel = DeckId;
		Descriptor.SegmentId = FString::Printf(TEXT("unknown|%s"), *Descriptor.MethodKey);
		return Descriptor;
	}

	double ComputeDaysUntilDue(const FString& DueAtUtc, const FString& ReferenceUtc)
	{
		FDateTime DueAt;
		FDateTime ReferenceTime;
		if (!TryParseUtc(DueAtUtc, DueAt) || !TryParseUtc(ReferenceUtc, ReferenceTime))
		{
			return 0.0;
		}

		return (DueAt - ReferenceTime).GetTotalDays();
	}

	double ClampDouble(double Value, double Min, double Max)
	{
		return FMath::Min(Max, FMath::Max(Min, Value));
	}

	double MeanRevertDifficulty(double Value)
	{
		return ClampDouble(DefaultDifficultyScore + 0.8 * (Value - DefaultDifficultyScore), 1.0, 10.0);
	}

	bool IsSuccessfulReview(const FHyperTwistTrainingReviewHistoryEntry& Entry)
	{
		return Entry.Grade != EHyperTwistTrainingReviewGrade::Again;
	}

	double ComputeElapsedDays(const FString& OlderUtc, const FString& NewerUtc)
	{
		FDateTime OlderTime;
		FDateTime NewerTime;
		if (!TryParseUtc(OlderUtc, OlderTime) || !TryParseUtc(NewerUtc, NewerTime) || NewerTime <= OlderTime)
		{
			return 0.0;
		}

		return (NewerTime - OlderTime).GetTotalDays();
	}

	int32 ComputeElapsedMilliseconds(const FString& OlderUtc, const FString& NewerUtc)
	{
		FDateTime OlderTime;
		FDateTime NewerTime;
		if (!TryParseUtc(OlderUtc, OlderTime) || !TryParseUtc(NewerUtc, NewerTime) || NewerTime <= OlderTime)
		{
			return 0;
		}

		return static_cast<int32>((NewerTime - OlderTime).GetTotalMilliseconds());
	}

	FString AddDaysToUtc(const FString& ReviewedAtUtc, double Days)
	{
		FDateTime ReviewedAt;
		if (!TryParseUtc(ReviewedAtUtc, ReviewedAt))
		{
			return FString();
		}

		return (ReviewedAt + FTimespan::FromDays(Days)).ToIso8601();
	}

	FString ResolvePlanStartUtc(const FHyperTwistTrainingReviewPlanState& ReviewPlan)
	{
		if (!ReviewPlan.StartedAtUtc.IsEmpty())
		{
			return ReviewPlan.StartedAtUtc;
		}

		return ReviewPlan.CreatedAtUtc;
	}

	FHyperTwistTrainingCoachMemorySnapshot DeriveQueueRecoveryBiasSnapshot(
		const FHyperTwistTrainingRepositoryState& RepositoryState,
		const FString& UserId,
		const FString& ReferenceUtc)
	{
		FHyperTwistTrainingCoachMemorySnapshot Snapshot;
		if (UserId.IsEmpty())
		{
			return Snapshot;
		}

		Snapshot.UserId = UserId;
		Snapshot.ReferenceUtc = ResolveReferenceUtc(ReferenceUtc);

		const TArray<FHyperTwistTrainingCoachSessionQueueState> QueueStates =
			UHyperTwistTrainingRepositoryLibrary::ListCoachSessionQueueStatesForUser(
				RepositoryState,
				UserId
			);
		if (QueueStates.Num() <= 0)
		{
			return Snapshot;
		}

		const FHyperTwistTrainingCoachSessionQueueState& ActiveQueueState = QueueStates[0];
		const FHyperTwistTrainingCoachSessionQueueExecutionSummary QueueExecutionSummary =
			UHyperTwistTrainingRepositoryLibrary::DeriveCoachSessionQueueExecutionSummary(
				RepositoryState,
				UserId,
				ActiveQueueState.QueueId,
				Snapshot.ReferenceUtc
			);
		if (!QueueExecutionSummary.IsStructurallyValid())
		{
			return Snapshot;
		}

		Snapshot.FocusDeckId = QueueExecutionSummary.FocusDeckId;
		Snapshot.FocusMethodSegmentId = QueueExecutionSummary.FocusMethodSegmentId;

		const FHyperTwistTrainingCoachSessionQueueStateEntry* MostDeferredQueueEntry =
			FindQueueEntryById(ActiveQueueState, QueueExecutionSummary.MostDeferredEntryId);
		const FHyperTwistTrainingCoachSessionQueueStateEntry* MostCompletedQueueEntry =
			FindQueueEntryById(ActiveQueueState, QueueExecutionSummary.MostCompletedEntryId);
		const EHyperTwistTrainingCoachGuidanceLane DominantDeferredLane =
			GuidanceLaneFromQueueEntry(MostDeferredQueueEntry);
		const EHyperTwistTrainingCoachGuidanceLane DominantCompletedLane =
			GuidanceLaneFromQueueEntry(MostCompletedQueueEntry);
		const int32 DeferredRecoverySignal = FMath::Clamp(
			(QueueExecutionSummary.DeferredEventCount / 2)
				+ (QueueExecutionSummary.ManualRescheduleEventCount > 0 ? 1 : 0),
			0,
			3
		);
		const int32 PromotionRecoverySignal = FMath::Clamp(
			QueueExecutionSummary.PromotedEventCount
				+ (QueueExecutionSummary.CompletedEventCount > 0 ? 1 : 0),
			0,
			3
		);
		const int32 ExplicitFollowUpRecoverySignal = FMath::Clamp(
			(QueueExecutionSummary.PromotedFollowUpEventCount * 2)
				+ QueueExecutionSummary.StartedFollowUpEventCount
				+ QueueExecutionSummary.CompletedFollowUpEventCount,
			0,
			5
		);
		const int32 ExplicitRecommendedRecoverySignal = FMath::Clamp(
			(QueueExecutionSummary.PromotedRecommendedEventCount * 2)
				+ QueueExecutionSummary.StartedRecommendedEventCount
				+ QueueExecutionSummary.CompletedRecommendedEventCount,
			0,
			5
		);
		const int32 ExplicitQueuedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedQueuedHandoffEventCount,
			0,
			3
		);
		const int32 ExplicitFollowUpHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedFollowUpHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitRecommendedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedRecommendedHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitDeferredOverflowQueuedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedDeferredOverflowQueuedHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitDeferredOverflowFollowUpHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedDeferredOverflowFollowUpHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitDeferredOverflowRecommendedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedDeferredOverflowRecommendedHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitDeferredFirstQueuedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedDeferredFirstQueuedHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitDeferredFirstFollowUpHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedDeferredFirstFollowUpHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitDeferredFirstRecommendedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedDeferredFirstRecommendedHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitMethodDrillQueuedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedMethodDrillQueuedHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitMethodDrillFollowUpHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedMethodDrillFollowUpHandoffEventCount * 2,
			0,
			4
		);
		const int32 ExplicitMethodDrillRecommendedHandoffSignal = FMath::Clamp(
			QueueExecutionSummary.StartedMethodDrillRecommendedHandoffEventCount * 2,
			0,
			4
		);
		const int32 MethodDrillRecoveryStartedCount =
			QueueExecutionSummary.StartedMethodDrillQueuedHandoffEventCount
			+ QueueExecutionSummary.StartedMethodDrillFollowUpHandoffEventCount
			+ QueueExecutionSummary.StartedMethodDrillRecommendedHandoffEventCount;
		const int32 MethodDrillRecoveryCompletedCount =
			QueueExecutionSummary.CompletedMethodDrillQueuedHandoffEventCount
			+ QueueExecutionSummary.CompletedMethodDrillFollowUpHandoffEventCount
			+ QueueExecutionSummary.CompletedMethodDrillRecommendedHandoffEventCount;
		const int32 MethodDrillRecoveryOutstandingCount = FMath::Max(
			0,
			MethodDrillRecoveryStartedCount - MethodDrillRecoveryCompletedCount
		);
		const int32 StrongMethodDrillRecoveryMemoryStartedCount =
			QueueExecutionSummary.StartedStrongMethodDrillRecoveryMemoryHandoffEventCount;
		const int32 StrongMethodDrillRecoveryMemoryCompletedCount =
			QueueExecutionSummary.CompletedStrongMethodDrillRecoveryMemoryHandoffEventCount;
		const int32 StrongMethodDrillRecoveryMemoryOutstandingCount = FMath::Max(
			0,
			StrongMethodDrillRecoveryMemoryStartedCount
				- StrongMethodDrillRecoveryMemoryCompletedCount
		);
		const int32 WeakMethodDrillRecoveryMemoryStartedCount =
			QueueExecutionSummary.StartedWeakMethodDrillRecoveryMemoryHandoffEventCount;
		const int32 WeakMethodDrillRecoveryMemoryCompletedCount =
			QueueExecutionSummary.CompletedWeakMethodDrillRecoveryMemoryHandoffEventCount;
		const int32 WeakMethodDrillRecoveryMemoryOutstandingCount = FMath::Max(
			0,
			WeakMethodDrillRecoveryMemoryStartedCount
				- WeakMethodDrillRecoveryMemoryCompletedCount
		);
		const int32 StrongRetainedMethodDrillRecoveryPostureStartedCount =
			QueueExecutionSummary.StartedStrongRetainedMethodDrillRecoveryPostureHandoffEventCount;
		const int32 StrongRetainedMethodDrillRecoveryPostureCompletedCount =
			QueueExecutionSummary.CompletedStrongRetainedMethodDrillRecoveryPostureHandoffEventCount;
		const int32 StrongRetainedMethodDrillRecoveryPostureOutstandingCount = FMath::Max(
			0,
			StrongRetainedMethodDrillRecoveryPostureStartedCount
				- StrongRetainedMethodDrillRecoveryPostureCompletedCount
		);
		const int32 WeakRetainedMethodDrillRecoveryPostureStartedCount =
			QueueExecutionSummary.StartedWeakRetainedMethodDrillRecoveryPostureHandoffEventCount;
		const int32 WeakRetainedMethodDrillRecoveryPostureCompletedCount =
			QueueExecutionSummary.CompletedWeakRetainedMethodDrillRecoveryPostureHandoffEventCount;
		const int32 WeakRetainedMethodDrillRecoveryPostureOutstandingCount = FMath::Max(
			0,
			WeakRetainedMethodDrillRecoveryPostureStartedCount
				- WeakRetainedMethodDrillRecoveryPostureCompletedCount
		);
		const int32 NarrowMethodDrillRecoveryStructureStartedCount =
			QueueExecutionSummary.StartedNarrowMethodDrillRecoveryStructureHandoffEventCount;
		const int32 NarrowMethodDrillRecoveryStructureCompletedCount =
			QueueExecutionSummary.CompletedNarrowMethodDrillRecoveryStructureHandoffEventCount;
		const int32 NarrowMethodDrillRecoveryStructureOutstandingCount = FMath::Max(
			0,
			NarrowMethodDrillRecoveryStructureStartedCount
				- NarrowMethodDrillRecoveryStructureCompletedCount
		);
		const int32 BroadMethodDrillRecoveryStructureStartedCount =
			QueueExecutionSummary.StartedBroadMethodDrillRecoveryStructureHandoffEventCount;
		const int32 BroadMethodDrillRecoveryStructurePromotedCount =
			QueueExecutionSummary.PromotedBroadMethodDrillRecoveryStructureHandoffEventCount;
		const int32 BroadMethodDrillRecoveryStructureCompletedCount =
			QueueExecutionSummary.CompletedBroadMethodDrillRecoveryStructureHandoffEventCount;
		const int32 BroadMethodDrillRecoveryStructureOutstandingCount = FMath::Max(
			0,
			BroadMethodDrillRecoveryStructureStartedCount
				- BroadMethodDrillRecoveryStructureCompletedCount
		);
		const int32 TightMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TightMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TightMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TightMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
			0,
			TightMethodDrillRecoveryStructurePlanStartedCount
				- TightMethodDrillRecoveryStructurePlanCompletedCount
		);
		const int32 BroadMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 BroadMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 BroadMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 BroadMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
			0,
			BroadMethodDrillRecoveryStructurePlanStartedCount
				- BroadMethodDrillRecoveryStructurePlanCompletedCount
		);
		const int32 TrustedTightMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TrustedTightMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TrustedTightMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TrustedTightMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
			0,
			TrustedTightMethodDrillRecoveryStructurePlanStartedCount
				- TrustedTightMethodDrillRecoveryStructurePlanCompletedCount
		);
		const int32 TrustedBroadMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
			0,
			TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				- TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
		);
		const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
			0,
			ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
				- ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
		);
		const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
			0,
			ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				- ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
		);
		const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount =
			FMath::Max(
				0,
				ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					- ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
			);
		const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount =
			QueueExecutionSummary.StartedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount =
			QueueExecutionSummary.PromotedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount =
			QueueExecutionSummary.CompletedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
		const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount =
			FMath::Max(
				0,
				ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					- ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
			);
		const int32 AcceptedAlignedTightPacketTrustStartedCount =
			QueueExecutionSummary.StartedAcceptedAlignedTightFollowUpPacketTrustHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustCompletedCount =
			QueueExecutionSummary.CompletedAcceptedAlignedTightFollowUpPacketTrustHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustStartedCount =
			QueueExecutionSummary.StartedAcceptedAlignedBroadRecommendedPacketTrustHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustCompletedCount =
			QueueExecutionSummary.CompletedAcceptedAlignedBroadRecommendedPacketTrustHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableOutcomeStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableOutcomeCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableOutcomeStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableOutcomeCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		if (MethodDrillRecoveryStartedCount > 0)
		{
			Snapshot.MethodDrillRecoveryHistoryCount += MethodDrillRecoveryStartedCount;
			Snapshot.StrongMethodDrillRecoveryHistoryCount += MethodDrillRecoveryCompletedCount;
			Snapshot.WeakMethodDrillRecoveryHistoryCount += MethodDrillRecoveryOutstandingCount;
			Snapshot.MethodDrillRecoveryAverageOutcomeScore =
				(static_cast<float>(MethodDrillRecoveryCompletedCount) * 100.0f)
				/ static_cast<float>(MethodDrillRecoveryStartedCount);
		}
		if ((TrustedTightMethodDrillRecoveryStructurePlanStartedCount
				+ TrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
			> 0)
		{
			const int32 TrustedTightMethodDrillRecoveryStructurePlanEventCount =
				TrustedTightMethodDrillRecoveryStructurePlanStartedCount
				+ TrustedTightMethodDrillRecoveryStructurePlanPromotedCount;
			Snapshot.TrustedTightMethodDrillRecoveryStructurePlanHistoryCount +=
				TrustedTightMethodDrillRecoveryStructurePlanEventCount;
			Snapshot.TrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore =
				(static_cast<float>(TrustedTightMethodDrillRecoveryStructurePlanCompletedCount)
					* 100.0f)
				/ static_cast<float>(TrustedTightMethodDrillRecoveryStructurePlanEventCount);
		}
		if ((TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				+ TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
			> 0)
		{
			const int32 TrustedBroadMethodDrillRecoveryStructurePlanEventCount =
				TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				+ TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount;
			const int32 TrustedBroadMethodDrillRecoveryStructurePlanRedirectCount = FMath::Max(
				0,
				TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
					+ TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
					- TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
			);
			Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanHistoryCount +=
				TrustedBroadMethodDrillRecoveryStructurePlanEventCount;
			Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore =
				(static_cast<float>(TrustedBroadMethodDrillRecoveryStructurePlanRedirectCount)
					* 100.0f)
				/ static_cast<float>(TrustedBroadMethodDrillRecoveryStructurePlanEventCount);
		}
		if ((ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
			> 0)
		{
			const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanEventCount =
				ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount;
			Snapshot.ReliableTrustedTightMethodDrillRecoveryStructurePlanHistoryCount +=
				ReliableTrustedTightMethodDrillRecoveryStructurePlanEventCount;
			Snapshot.ReliableTrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore =
				(static_cast<float>(ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount)
					* 100.0f)
				/ static_cast<float>(ReliableTrustedTightMethodDrillRecoveryStructurePlanEventCount);
		}
		if ((ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
			> 0)
		{
			const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanEventCount =
				ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount;
			const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount =
				FMath::Max(
					0,
					ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
						- ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
				);
			Snapshot.ReliableTrustedBroadMethodDrillRecoveryStructurePlanHistoryCount +=
				ReliableTrustedBroadMethodDrillRecoveryStructurePlanEventCount;
			Snapshot.ReliableTrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore =
				(static_cast<float>(ReliableTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount)
					* 100.0f)
				/ static_cast<float>(ReliableTrustedBroadMethodDrillRecoveryStructurePlanEventCount);
		}
		if ((ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
			> 0)
		{
			const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanEventCount =
				ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount;
			Snapshot.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHistoryCount +=
				ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanEventCount;
			Snapshot.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore =
				(static_cast<float>(
					 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount)
					* 100.0f)
				/ static_cast<float>(ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanEventCount);
		}
		if ((ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
			> 0)
		{
			const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanEventCount =
				ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
				+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount;
			const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount =
				FMath::Max(
					0,
					ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
						- ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
				);
			Snapshot.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHistoryCount +=
				ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanEventCount;
			Snapshot.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore =
				(static_cast<float>(
					 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount)
					* 100.0f)
				/ static_cast<float>(ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanEventCount);
		}
		if (AcceptedAlignedTightPacketTrustStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount +=
				AcceptedAlignedTightPacketTrustStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableAverageOutcomeScore =
				(static_cast<float>(AcceptedAlignedTightPacketTrustCompletedCount) * 100.0f)
				/ static_cast<float>(AcceptedAlignedTightPacketTrustStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount +=
				AcceptedAlignedBroadPacketTrustStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore =
				(static_cast<float>(AcceptedAlignedBroadPacketTrustCompletedCount) * 100.0f)
				/ static_cast<float>(AcceptedAlignedBroadPacketTrustStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableOutcomeStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableOutcomeStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAcceptedAverageScore =
				(static_cast<float>(AcceptedAlignedTightPacketTrustReliableOutcomeCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedTightPacketTrustReliableOutcomeStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableOutcomeStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableOutcomeStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAcceptedAverageScore =
				(static_cast<float>(AcceptedAlignedBroadPacketTrustReliableOutcomeCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedBroadPacketTrustReliableOutcomeStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactAcceptedAverageScore =
				(static_cast<float>(AcceptedAlignedTightPacketTrustReliableExactCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedTightPacketTrustReliableExactStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactAcceptedAverageScore =
				(static_cast<float>(AcceptedAlignedBroadPacketTrustReliableExactCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedBroadPacketTrustReliableExactStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAcceptedAverageScore =
				(static_cast<float>(AcceptedAlignedTightPacketTrustReliableExactOutcomeCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedTightPacketTrustReliableExactOutcomeStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAcceptedAverageScore =
				(static_cast<float>(AcceptedAlignedBroadPacketTrustReliableExactOutcomeCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedBroadPacketTrustReliableExactOutcomeStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore =
				(static_cast<float>(AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore =
				(static_cast<float>(AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount =
			QueueExecutionSummary
				.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		const int32 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount =
			QueueExecutionSummary
				.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount;
		if (AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedTightPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		if (AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount > 0)
		{
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount +=
				AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount;
			Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore =
				(static_cast<float>(
					 AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableCompletedCount)
					* 100.0f)
				/ static_cast<float>(
					AcceptedAlignedBroadPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableStartedCount);
		}
		const bool bStrongMethodDrillRecoveryHistory =
			MethodDrillRecoveryStartedCount >= 2
			&& MethodDrillRecoveryCompletedCount >= MethodDrillRecoveryOutstandingCount
			&& Snapshot.MethodDrillRecoveryAverageOutcomeScore >= 55.0f;
		const bool bWeakMethodDrillRecoveryHistory =
			MethodDrillRecoveryStartedCount >= 2
			&& MethodDrillRecoveryOutstandingCount > MethodDrillRecoveryCompletedCount
			&& Snapshot.MethodDrillRecoveryAverageOutcomeScore <= 45.0f;
		const int32 MethodDrillRecoveryLaunchBias = bStrongMethodDrillRecoveryHistory
			? FMath::Clamp(
				MethodDrillRecoveryCompletedCount
					- MethodDrillRecoveryOutstandingCount
					+ (Snapshot.MethodDrillRecoveryAverageOutcomeScore >= 75.0f ? 1 : 0),
				1,
				3)
			: 0;
		const int32 MethodDrillRecoveryPromoteBias = bWeakMethodDrillRecoveryHistory
			? FMath::Clamp(
				MethodDrillRecoveryOutstandingCount
					- MethodDrillRecoveryCompletedCount
					+ (QueueExecutionSummary.bHasCompletionGap ? 1 : 0),
				1,
				3)
			: 0;
		const int32 RetainedMethodDrillRecoveryLaunchBias =
			StrongMethodDrillRecoveryMemoryStartedCount > 0
				? FMath::Clamp(
					(StrongMethodDrillRecoveryMemoryCompletedCount * 2)
						- StrongMethodDrillRecoveryMemoryStartedCount
						+ 1,
					1,
					3)
				: 0;
		const int32 RetainedMethodDrillRecoveryPromoteBias =
			WeakMethodDrillRecoveryMemoryStartedCount > 0
				? FMath::Clamp(
					(WeakMethodDrillRecoveryMemoryOutstandingCount * 2)
						- WeakMethodDrillRecoveryMemoryCompletedCount
						+ 1,
					1,
					3)
				: 0;
		const int32 RetainedMethodDrillRecoveryPostureLaunchBias =
			StrongRetainedMethodDrillRecoveryPostureStartedCount > 0
				? FMath::Clamp(
					(StrongRetainedMethodDrillRecoveryPostureCompletedCount * 2)
						- StrongRetainedMethodDrillRecoveryPostureOutstandingCount
						+ 1,
					1,
					3)
				: 0;
		const int32 RetainedMethodDrillRecoveryPosturePromoteBias =
			WeakRetainedMethodDrillRecoveryPostureStartedCount > 0
				? FMath::Clamp(
					(WeakRetainedMethodDrillRecoveryPostureOutstandingCount * 2)
						- WeakRetainedMethodDrillRecoveryPostureCompletedCount
						+ 1,
					1,
					3)
				: 0;
		const int32 NarrowMethodDrillRecoveryStructureLaunchBias =
			NarrowMethodDrillRecoveryStructureStartedCount >= 2
				? FMath::Clamp(
					(NarrowMethodDrillRecoveryStructureCompletedCount * 2)
						- NarrowMethodDrillRecoveryStructureOutstandingCount
						+ 1,
					1,
					3)
				: 0;
		const int32 BroadMethodDrillRecoveryStructurePromoteBias =
			(BroadMethodDrillRecoveryStructurePromotedCount
					+ BroadMethodDrillRecoveryStructureStartedCount)
					>= 2
				? FMath::Clamp(
					BroadMethodDrillRecoveryStructurePromotedCount
						+ BroadMethodDrillRecoveryStructureOutstandingCount
						- BroadMethodDrillRecoveryStructureCompletedCount
						+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
					1,
					3)
				: 0;
		const int32 TightMethodDrillRecoveryStructurePlanLaunchBias =
			(TightMethodDrillRecoveryStructurePlanStartedCount
					+ TightMethodDrillRecoveryStructurePlanPromotedCount)
					>= 2
				? FMath::Clamp(
					(TightMethodDrillRecoveryStructurePlanCompletedCount * 2)
						- TightMethodDrillRecoveryStructurePlanOutstandingCount
						- TightMethodDrillRecoveryStructurePlanPromotedCount
						+ 1,
					1,
					3)
				: 0;
		const int32 BroadMethodDrillRecoveryStructurePlanPromoteBias =
			(BroadMethodDrillRecoveryStructurePlanPromotedCount
					+ BroadMethodDrillRecoveryStructurePlanStartedCount)
					>= 2
				? FMath::Clamp(
					BroadMethodDrillRecoveryStructurePlanPromotedCount
						+ BroadMethodDrillRecoveryStructurePlanOutstandingCount
						- BroadMethodDrillRecoveryStructurePlanCompletedCount
						+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
					1,
					3)
				: 0;
		const bool bTrustedTightMethodDrillRecoveryStructurePlanHistory =
			(TrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ TrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
				>= 2
			&& TrustedTightMethodDrillRecoveryStructurePlanCompletedCount
				>= TrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
			&& Snapshot.TrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore >= 60.0f;
		const bool bTrustedBroadMethodDrillRecoveryStructurePlanHistory =
			(TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
				>= 2
			&& (TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
					+ TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount)
				>= TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
			&& Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore >= 60.0f;
		const int32 TrustedTightMethodDrillRecoveryStructurePlanLaunchBias =
			bTrustedTightMethodDrillRecoveryStructurePlanHistory
				? FMath::Clamp(
					(TrustedTightMethodDrillRecoveryStructurePlanCompletedCount * 2)
						- TrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
						- TrustedTightMethodDrillRecoveryStructurePlanPromotedCount
						+ (Snapshot.TrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore
								>= 80.0f
							? 1
							: 0),
					1,
					3)
				: 0;
		const int32 TrustedBroadMethodDrillRecoveryStructurePlanPromoteBias =
			bTrustedBroadMethodDrillRecoveryStructurePlanHistory
				? FMath::Clamp(
					TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
						- TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
						+ (Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore
								>= 80.0f
							? 1
							: 0)
						+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
					1,
					3)
				: 0;
		const bool bReliableTrustedTightMethodDrillRecoveryStructurePlanHistory =
			(ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
				>= 2
			&& ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
				>= ReliableTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
			&& Snapshot.ReliableTrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore
				>= 60.0f;
		const bool bReliableTrustedBroadMethodDrillRecoveryStructurePlanHistory =
			(ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
				>= 2
			&& (ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
					+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount)
				>= ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
			&& Snapshot.ReliableTrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore
				>= 60.0f;
		const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanLaunchBias =
			bReliableTrustedTightMethodDrillRecoveryStructurePlanHistory
				? FMath::Clamp(
					(ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount * 2)
						- ReliableTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
						- ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount
						+ 1,
					1,
					3)
				: 0;
		const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias =
			bReliableTrustedBroadMethodDrillRecoveryStructurePlanHistory
				? FMath::Clamp(
					ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
						- ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
						+ 1
						+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
					1,
					3)
				: 0;
		const bool bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHistory =
			(ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
				>= 2
			&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
				>= ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount;
		const bool bReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHistory =
			(ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
				>= 2
			&& (ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
					+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount)
				>= ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount;
		const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias =
			bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHistory
				? FMath::Clamp(
					(ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount * 2)
						- ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
						- ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount
						+ 2,
					1,
					4)
				: 0;
		const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias =
			bReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHistory
				? FMath::Clamp(
					ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
						- ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
						+ 2
						+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
					1,
					4)
				: 0;
		const bool bStrongMethodDrillRecoveryPacketQueuedHandoff =
			QueueExecutionSummary.StartedStrongMethodDrillRecoveryPacketQueuedHandoffEventCount > 0;
		const bool bStrongMethodDrillRecoveryPacketFollowUpHandoff =
			QueueExecutionSummary.StartedStrongMethodDrillRecoveryPacketFollowUpHandoffEventCount > 0;
		const bool bStrongMethodDrillRecoveryPacketRecommendedHandoff =
			QueueExecutionSummary.StartedStrongMethodDrillRecoveryPacketRecommendedHandoffEventCount > 0;
		const bool bWeakMethodDrillRecoveryPacketQueuedHandoff =
			QueueExecutionSummary.StartedWeakMethodDrillRecoveryPacketQueuedHandoffEventCount > 0;
		const bool bWeakMethodDrillRecoveryPacketFollowUpHandoff =
			QueueExecutionSummary.StartedWeakMethodDrillRecoveryPacketFollowUpHandoffEventCount > 0;
		const bool bWeakMethodDrillRecoveryPacketRecommendedHandoff =
			QueueExecutionSummary.StartedWeakMethodDrillRecoveryPacketRecommendedHandoffEventCount > 0;
		if (ExplicitQueuedHandoffSignal > 0
			|| ExplicitFollowUpHandoffSignal > 0
			|| ExplicitRecommendedHandoffSignal > 0)
		{
			if (ExplicitQueuedHandoffSignal >= ExplicitFollowUpHandoffSignal
				&& ExplicitQueuedHandoffSignal >= ExplicitRecommendedHandoffSignal)
			{
				const bool bRetainedMethodDrillRecoveryPostureDriven =
					ExplicitMethodDrillQueuedHandoffSignal > 0
					&& RetainedMethodDrillRecoveryPostureLaunchBias > 0;
				const EMethodDrillRecoveryMemoryBias MethodDrillRecoveryMemoryBias =
					bRetainedMethodDrillRecoveryPostureDriven
						? EMethodDrillRecoveryMemoryBias::Strong
						: (ExplicitMethodDrillQueuedHandoffSignal > 0
						&& RetainedMethodDrillRecoveryLaunchBias > 0
						? EMethodDrillRecoveryMemoryBias::Strong
						: EMethodDrillRecoveryMemoryBias::None);
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Queue;
				if (bStrongMethodDrillRecoveryPacketQueuedHandoff)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-queued");
				}
				else if (bWeakMethodDrillRecoveryPacketQueuedHandoff)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-queued");
				}
				else if (MethodDrillRecoveryMemoryBias == EMethodDrillRecoveryMemoryBias::Strong
					&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued");
				}
				else if (MethodDrillRecoveryMemoryBias == EMethodDrillRecoveryMemoryBias::Strong
					&& ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount > 0)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-queued");
				}
				else
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::Queue,
							ExplicitDeferredOverflowQueuedHandoffSignal > 0,
							ExplicitDeferredFirstQueuedHandoffSignal > 0,
							ExplicitMethodDrillQueuedHandoffSignal > 0,
							MethodDrillRecoveryMemoryBias,
							bRetainedMethodDrillRecoveryPostureDriven
						);
				}
			}
			else if (ExplicitFollowUpHandoffSignal >= ExplicitRecommendedHandoffSignal)
			{
				const bool bRetainedMethodDrillRecoveryPostureDriven =
					ExplicitMethodDrillFollowUpHandoffSignal > 0
					&& RetainedMethodDrillRecoveryPostureLaunchBias > 0;
				const EMethodDrillRecoveryMemoryBias MethodDrillRecoveryMemoryBias =
					bRetainedMethodDrillRecoveryPostureDriven
						? EMethodDrillRecoveryMemoryBias::Strong
						: (ExplicitMethodDrillFollowUpHandoffSignal > 0
						&& RetainedMethodDrillRecoveryLaunchBias > 0
						? EMethodDrillRecoveryMemoryBias::Strong
						: EMethodDrillRecoveryMemoryBias::None);
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				if (bStrongMethodDrillRecoveryPacketFollowUpHandoff)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-follow-up");
				}
				else if (bWeakMethodDrillRecoveryPacketFollowUpHandoff)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-follow-up");
				}
				else if (MethodDrillRecoveryMemoryBias == EMethodDrillRecoveryMemoryBias::Strong
					&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up");
				}
				else if (MethodDrillRecoveryMemoryBias == EMethodDrillRecoveryMemoryBias::Strong
					&& ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount > 0)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up");
				}
				else
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::FollowUp,
							ExplicitDeferredOverflowFollowUpHandoffSignal > 0,
							ExplicitDeferredFirstFollowUpHandoffSignal > 0,
							ExplicitMethodDrillFollowUpHandoffSignal > 0,
							MethodDrillRecoveryMemoryBias,
							bRetainedMethodDrillRecoveryPostureDriven
						);
				}
			}
			else
			{
				const bool bRetainedMethodDrillRecoveryPostureDriven =
					ExplicitMethodDrillRecommendedHandoffSignal > 0
					&& RetainedMethodDrillRecoveryPosturePromoteBias > 0;
				const EMethodDrillRecoveryMemoryBias MethodDrillRecoveryMemoryBias =
					bRetainedMethodDrillRecoveryPostureDriven
						? EMethodDrillRecoveryMemoryBias::Weak
						: (ExplicitMethodDrillRecommendedHandoffSignal > 0
						&& RetainedMethodDrillRecoveryPromoteBias > 0
						? EMethodDrillRecoveryMemoryBias::Weak
						: EMethodDrillRecoveryMemoryBias::None);
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				if (bStrongMethodDrillRecoveryPacketRecommendedHandoff)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-recommended");
				}
				else if (bWeakMethodDrillRecoveryPacketRecommendedHandoff)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-recommended");
				}
				else if (MethodDrillRecoveryMemoryBias == EMethodDrillRecoveryMemoryBias::Weak
					&& ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias > 0)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended");
				}
				else if (MethodDrillRecoveryMemoryBias == EMethodDrillRecoveryMemoryBias::Weak
					&& ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount > 0)
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended");
				}
				else
				{
					Snapshot.PreferredCoachHandoffSourceLabel =
						HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::Recommended,
							ExplicitDeferredOverflowRecommendedHandoffSignal > 0,
							ExplicitDeferredFirstRecommendedHandoffSignal > 0,
							ExplicitMethodDrillRecommendedHandoffSignal > 0,
							MethodDrillRecoveryMemoryBias,
							bRetainedMethodDrillRecoveryPostureDriven
						);
				}
			}
		}
		const int32 WeightedFollowUpRecoverySignal =
			ExplicitFollowUpRecoverySignal
			+ ExplicitFollowUpHandoffSignal
			+ ExplicitDeferredOverflowFollowUpHandoffSignal
			+ ExplicitDeferredFirstQueuedHandoffSignal
			+ ExplicitDeferredFirstFollowUpHandoffSignal
			+ ExplicitMethodDrillQueuedHandoffSignal
			+ ExplicitMethodDrillFollowUpHandoffSignal
			+ MethodDrillRecoveryLaunchBias
			+ RetainedMethodDrillRecoveryLaunchBias
			+ RetainedMethodDrillRecoveryPostureLaunchBias
			+ TightMethodDrillRecoveryStructurePlanLaunchBias
			+ NarrowMethodDrillRecoveryStructureLaunchBias;
		const int32 WeightedRecommendedRecoverySignal =
			ExplicitRecommendedRecoverySignal
			+ ExplicitRecommendedHandoffSignal
			+ ExplicitDeferredOverflowRecommendedHandoffSignal
			+ ExplicitDeferredFirstRecommendedHandoffSignal
			+ ExplicitMethodDrillRecommendedHandoffSignal
			+ MethodDrillRecoveryPromoteBias
			+ RetainedMethodDrillRecoveryPromoteBias
			+ RetainedMethodDrillRecoveryPosturePromoteBias
			+ BroadMethodDrillRecoveryStructurePlanPromoteBias
			+ BroadMethodDrillRecoveryStructurePromoteBias;
		const bool bQueueHistoryPrefersFollowUp =
			DominantDeferredLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
			|| (DominantCompletedLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				&& QueueExecutionSummary.PromotedEventCount > 0)
			|| WeightedFollowUpRecoverySignal > WeightedRecommendedRecoverySignal;
		const bool bQueueHistoryPrefersRecommended =
			DominantDeferredLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
			|| (DominantCompletedLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				&& QueueExecutionSummary.PromotedEventCount > 0)
			|| WeightedRecommendedRecoverySignal > WeightedFollowUpRecoverySignal;
		const float PromoteRecoveryActionPressure =
			(QueueExecutionSummary.bHasOutstandingDeferredWork ? 4.0f : 0.0f)
			+ FMath::Min(static_cast<float>(QueueExecutionSummary.DeferredEventCount) * 0.75f, 3.0f)
			+ FMath::Min(static_cast<float>(QueueExecutionSummary.PromotedEventCount), 3.0f)
			+ (DominantDeferredLane != EHyperTwistTrainingCoachGuidanceLane::None ? 1.5f : 0.0f)
			- (QueueExecutionSummary.bHasCompletionGap ? 1.0f : 0.0f)
			+ (static_cast<float>(MethodDrillRecoveryPromoteBias) * 1.5f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryPromoteBias) * 1.75f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryPosturePromoteBias) * 2.0f)
			+ (static_cast<float>(BroadMethodDrillRecoveryStructurePromoteBias) * 2.5f);
		const float LaunchRecoveryActionPressure =
			(QueueExecutionSummary.bHasCompletionGap ? 4.0f : 0.0f)
			+ (QueueExecutionSummary.bHasBlockedFollowUpFriction ? 2.5f : 0.0f)
			+ (QueueExecutionSummary.bHasRepeatManualRescheduleFriction ? 2.0f : 0.0f)
			+ (QueueExecutionSummary.bHasArchiveAwareFriction ? 1.0f : 0.0f)
			+ FMath::Min(static_cast<float>(QueueExecutionSummary.CompletedEventCount), 3.0f)
			+ FMath::Min(static_cast<float>(QueueExecutionSummary.ManualRescheduleEventCount) * 0.5f, 2.0f)
			+ static_cast<float>(ExplicitQueuedHandoffSignal)
			+ static_cast<float>(ExplicitDeferredOverflowQueuedHandoffSignal)
			+ static_cast<float>(ExplicitDeferredFirstQueuedHandoffSignal)
			+ static_cast<float>(ExplicitDeferredFirstFollowUpHandoffSignal) * 0.5f
			+ static_cast<float>(ExplicitMethodDrillQueuedHandoffSignal)
			+ static_cast<float>(ExplicitMethodDrillFollowUpHandoffSignal)
			+ static_cast<float>(ExplicitMethodDrillRecommendedHandoffSignal) * 0.5f
			+ (static_cast<float>(MethodDrillRecoveryLaunchBias) * 1.75f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryLaunchBias) * 2.0f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryPostureLaunchBias) * 2.25f)
			+ (static_cast<float>(TightMethodDrillRecoveryStructurePlanLaunchBias) * 2.75f)
			+ (static_cast<float>(NarrowMethodDrillRecoveryStructureLaunchBias) * 2.5f);
		if (PromoteRecoveryActionPressure > 0.0f || LaunchRecoveryActionPressure > 0.0f)
		{
			const FString PacketStructureRecoverySourceLabel =
				HyperTwistTrainingRepositoryLibraryInternal::
					ResolveMethodDrillFollowUpPacketStructureRecoverySourceLabel(
						Snapshot.PreferredCoachHandoffSourceLabel,
						Snapshot.PreferredGuidanceSourceLabel
					);
			if (PromoteRecoveryActionPressure > LaunchRecoveryActionPressure)
			{
				Snapshot.PreferredQueueRecoveryAction =
					EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred;
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					!PacketStructureRecoverySourceLabel.IsEmpty()
						? PacketStructureRecoverySourceLabel
						: TEXT("queue-history-promote-pressure");
			}
			else if (LaunchRecoveryActionPressure > PromoteRecoveryActionPressure)
			{
				Snapshot.PreferredQueueRecoveryAction =
					EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery;
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					!PacketStructureRecoverySourceLabel.IsEmpty()
						? PacketStructureRecoverySourceLabel
						: (!Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
						? Snapshot.PreferredCoachHandoffSourceLabel
						: TEXT("queue-history-launch-pressure"));
			}
			else
			{
				Snapshot.PreferredQueueRecoveryAction =
					QueueExecutionSummary.bHasOutstandingDeferredWork
						&& !QueueExecutionSummary.bHasCompletionGap
						? EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
						: EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery;
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					!PacketStructureRecoverySourceLabel.IsEmpty()
						? PacketStructureRecoverySourceLabel
						: TEXT("queue-history-balanced-pressure");
			}
		}
		if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& HyperTwistTrainingRepositoryLibraryInternal::IsStrongMethodDrillRecoveryPacketCoachMemorySource(
				Snapshot.PreferredCoachHandoffSourceLabel))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-packet-strong");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& HyperTwistTrainingRepositoryLibraryInternal::IsWeakMethodDrillRecoveryPacketCoachMemorySource(
				Snapshot.PreferredCoachHandoffSourceLabel))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-packet-weak");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& ReliableTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& HyperTwistTrainingRepositoryLibraryInternal::
				IsTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& HyperTwistTrainingRepositoryLibraryInternal::
				IsTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted");
		}
		else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& TightMethodDrillRecoveryStructurePlanLaunchBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-tight");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& BroadMethodDrillRecoveryStructurePlanPromoteBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-plan-broad");
		}
		else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& NarrowMethodDrillRecoveryStructureLaunchBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-narrow");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& BroadMethodDrillRecoveryStructurePromoteBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-structure-broad");
		}
		else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& RetainedMethodDrillRecoveryPostureLaunchBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-posture-strong");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& RetainedMethodDrillRecoveryPosturePromoteBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-posture-weak");
		}
		else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& RetainedMethodDrillRecoveryLaunchBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-memory-strong");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& RetainedMethodDrillRecoveryPromoteBias > 0
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-memory-weak");
		}
		else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
			&& bStrongMethodDrillRecoveryHistory
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-strong");
		}
		else if (Snapshot.PreferredQueueRecoveryAction
				== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			&& bWeakMethodDrillRecoveryHistory
			&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
				|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
					Snapshot.PreferredQueueRecoveryActionSourceLabel)))
		{
			Snapshot.PreferredQueueRecoveryActionSourceLabel =
				TEXT("coach-memory-method-drill-recovery-weak");
		}

		if (bQueueHistoryPrefersFollowUp)
		{
			Snapshot.FollowUpGuidanceContinueBias += FMath::Max(
				1,
				DeferredRecoverySignal + PromotionRecoverySignal + WeightedFollowUpRecoverySignal
			);
		}
		if (bQueueHistoryPrefersRecommended)
		{
			Snapshot.RecommendedGuidanceContinueBias += FMath::Max(
				1,
				DeferredRecoverySignal + PromotionRecoverySignal + WeightedRecommendedRecoverySignal
					- (QueueExecutionSummary.bHasBlockedFollowUpFriction ? 1 : 0)
			);
		}
		if (MethodDrillRecoveryLaunchBias > 0)
		{
			Snapshot.FollowUpGuidanceContinueBias += MethodDrillRecoveryLaunchBias;
		}
		if (RetainedMethodDrillRecoveryLaunchBias > 0)
		{
			Snapshot.FollowUpGuidanceContinueBias += RetainedMethodDrillRecoveryLaunchBias;
		}
		if (NarrowMethodDrillRecoveryStructureLaunchBias > 0)
		{
			Snapshot.FollowUpGuidanceContinueBias += NarrowMethodDrillRecoveryStructureLaunchBias;
		}
		if (MethodDrillRecoveryPromoteBias > 0)
		{
			Snapshot.RecommendedGuidanceContinueBias += MethodDrillRecoveryPromoteBias;
		}
		if (RetainedMethodDrillRecoveryPromoteBias > 0)
		{
			Snapshot.RecommendedGuidanceContinueBias += RetainedMethodDrillRecoveryPromoteBias;
		}
		if (BroadMethodDrillRecoveryStructurePromoteBias > 0)
		{
			Snapshot.RecommendedGuidanceContinueBias += BroadMethodDrillRecoveryStructurePromoteBias;
		}
		if (bQueueHistoryPrefersFollowUp
			&& Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred)
		{
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				DeferredRecoverySignal
					+ WeightedFollowUpRecoverySignal
					+ (QueueExecutionSummary.bHasBlockedFollowUpFriction ? 1 : 0)
			);
		}
		if (bQueueHistoryPrefersRecommended
			&& Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery)
		{
			Snapshot.SuppressedFollowUpQueuePressureCount += FMath::Max(
				1,
				PromotionRecoverySignal
					+ WeightedRecommendedRecoverySignal
					+ (QueueExecutionSummary.bHasCompletionGap ? 1 : 0)
			);
		}

		if (bQueueHistoryPrefersFollowUp
			&& (QueueExecutionSummary.PromotedEventCount > 0
				|| QueueExecutionSummary.bHasBlockedFollowUpFriction
				|| QueueExecutionSummary.BlockedFollowUpEventCount > 0))
		{
			Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
			Snapshot.PreferredGuidanceSourceLabel = ExplicitFollowUpHandoffSignal > 0
				? HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
					EHyperTwistTrainingCoachHandoffKind::FollowUp,
					ExplicitDeferredOverflowFollowUpHandoffSignal > 0,
					ExplicitDeferredFirstFollowUpHandoffSignal > 0
						|| ExplicitDeferredFirstQueuedHandoffSignal > 0
				)
				: TEXT("coach-memory-queue-follow-up");
		}
			else if (bQueueHistoryPrefersRecommended
				&& Snapshot.PreferredGuidanceLane != EHyperTwistTrainingCoachGuidanceLane::FollowUp
				&& (QueueExecutionSummary.PromotedEventCount > 0
					|| QueueExecutionSummary.CompletedEventCount > 0))
			{
			Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
			Snapshot.PreferredGuidanceSourceLabel = ExplicitRecommendedHandoffSignal > 0
				? HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
					EHyperTwistTrainingCoachHandoffKind::Recommended,
					ExplicitDeferredOverflowRecommendedHandoffSignal > 0
				)
				: TEXT("coach-memory-queue-recommended");
		}

		return Snapshot;
	}

	void ResolveCoachActionPlanPreferenceDefaults(
		const FHyperTwistCoachBrief& CoachBrief,
		const FHyperTwistTrainingCoachMemorySnapshot& CoachMemorySnapshot,
		EHyperTwistTrainingDeliveryMode& InOutMode,
		EHyperTwistTrainingSelectionPolicy& InOutSelectionPolicy)
	{
		const bool bDeferredOverflowHandoffSource =
			HyperTwistTrainingRepositoryLibraryInternal::IsDeferredOverflowDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			);
		const bool bNarrowMethodDrillRecoveryStructureHandoffSource =
			HyperTwistTrainingRepositoryLibraryInternal::IsNarrowMethodDrillRecoveryStructureDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-narrow");
		const bool bTightMethodDrillRecoveryStructurePlanHandoffSource =
			HyperTwistTrainingRepositoryLibraryInternal::IsTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned");
		const bool bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffSource =
			HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned");
		const bool bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource =
			bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffSource
			|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable");
		const bool bBroadMethodDrillRecoveryStructureHandoffSource =
			HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructureDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-broad");
		const bool bBroadMethodDrillRecoveryStructurePlanHandoffSource =
			HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned");
		const bool bReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffSource =
			HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome")
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned");
		const bool bReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffSource =
			bReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffSource
			|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
			)
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable");
		const bool bStrongMethodDrillRecoveryMemoryHandoffSource =
			CoachMemorySnapshot.PreferredCoachHandoffSourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-method-drill-recovery-strong-"))
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-memory-strong");
		const bool bWeakMethodDrillRecoveryMemoryHandoffSource =
			CoachMemorySnapshot.PreferredCoachHandoffSourceLabel.StartsWith(
				TEXT("coach-memory-dashboard-method-drill-recovery-weak-"))
			|| CoachMemorySnapshot.PreferredQueueRecoveryActionSourceLabel
				== TEXT("coach-memory-method-drill-recovery-memory-weak");
		const bool bAlignedTightFollowUpGuidanceOutcomeSource =
			CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-aligned-tight-follow-up-outcome")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-outcome")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("coach-memory-aligned-follow-up-packet-structure-tight-follow-up")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-aligned-tight-follow-up-outcome")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-outcome")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("coach-memory-aligned-follow-up-packet-structure-tight-follow-up")
			|| (CoachMemorySnapshot.PreferredGuidanceLane
					== EHyperTwistTrainingCoachGuidanceLane::FollowUp
				&& CoachMemorySnapshot.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount >= 2
				&& CoachMemorySnapshot.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore >= 60.0f
				&& (CoachMemorySnapshot.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount <= 0
					|| CoachMemorySnapshot.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore
						>= CoachMemorySnapshot
							   .ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore
							- 2.0f));
		const bool bAlignedBroadRecommendedGuidanceOutcomeSource =
			CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-aligned-broad-recommended-outcome")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-outcome")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredGuidanceSourceLabel
				== TEXT("coach-memory-aligned-follow-up-packet-structure-broad-recommended")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-aligned-broad-recommended-outcome")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-outcome")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable")
			|| CoachMemorySnapshot.PreferredCoachHandoffSourceLabel
				== TEXT("coach-memory-aligned-follow-up-packet-structure-broad-recommended")
			|| (CoachMemorySnapshot.PreferredGuidanceLane
					== EHyperTwistTrainingCoachGuidanceLane::Recommended
				&& CoachMemorySnapshot.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount >= 2
				&& CoachMemorySnapshot.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore
					>= 58.0f
				&& (CoachMemorySnapshot.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount <= 0
					|| CoachMemorySnapshot
							   .ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore
						>= CoachMemorySnapshot
							   .ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore
							- 2.0f));
		const bool bTightMethodDrillRecoveryPlanSource =
			bStrongMethodDrillRecoveryMemoryHandoffSource
			|| bTightMethodDrillRecoveryStructurePlanHandoffSource
			|| bNarrowMethodDrillRecoveryStructureHandoffSource
			|| bAlignedTightFollowUpGuidanceOutcomeSource;
		const bool bBroadMethodDrillRecoveryPlanSource =
			bWeakMethodDrillRecoveryMemoryHandoffSource
			|| bBroadMethodDrillRecoveryStructurePlanHandoffSource
			|| bBroadMethodDrillRecoveryStructureHandoffSource
			|| bAlignedBroadRecommendedGuidanceOutcomeSource;
		if (CoachMemorySnapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Queue
			&& !CoachBrief.bNeedsCoachReview
			&& CoachBrief.FollowUpDepth <= 0)
		{
			if (bDeferredOverflowHandoffSource || bTightMethodDrillRecoveryPlanSource)
			{
				if (CoachBrief.bPreferRecognitionReplayReview
					&& CoachMemorySnapshot.DominantCoachSuggestedMode
						== EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
				}
				else if (InOutMode == EHyperTwistTrainingDeliveryMode::Timer
					|| InOutMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
				}
				else if (bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource
					&& InOutMode != EHyperTwistTrainingDeliveryMode::CoachReviewed
					&& InOutMode != EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
				}

				if (bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffSource)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				else if (bAlignedTightFollowUpGuidanceOutcomeSource)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				else if (bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				else if (bNarrowMethodDrillRecoveryStructureHandoffSource
					&& InOutSelectionPolicy != EHyperTwistTrainingSelectionPolicy::Scripted)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				else if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Weighted)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				return;
			}

			if (InOutMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
				&& CoachMemorySnapshot.DominantCoachSuggestedMode != EHyperTwistTrainingDeliveryMode::CoachReviewed)
			{
				InOutMode = CoachMemorySnapshot.DominantCoachSuggestedMode;
			}
			else if (InOutMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted
				&& CoachMemorySnapshot.DominantCoachSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer)
			{
				InOutMode = EHyperTwistTrainingDeliveryMode::Timer;
			}

			if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
			{
				InOutSelectionPolicy =
					CoachMemorySnapshot.DominantCoachSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted
						? EHyperTwistTrainingSelectionPolicy::Weighted
						: CoachMemorySnapshot.DominantCoachSelectionPolicy;
			}
			return;
		}

		if (CoachMemorySnapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp)
		{
			const bool bShouldBiasFollowUpHandoff =
				CoachBrief.FollowUpDepth > 0
				|| CoachBrief.bNeedsCoachReview
				|| CoachMemorySnapshot.FollowUpReadyCoachSequenceCount > 0
				|| CoachMemorySnapshot.ScheduleBlockedFollowUpEventCount > 0
				|| bTightMethodDrillRecoveryPlanSource
				|| bAlignedTightFollowUpGuidanceOutcomeSource;
			if (bShouldBiasFollowUpHandoff)
			{
				if (CoachBrief.bPreferRecognitionReplayReview
					&& CoachMemorySnapshot.DominantCoachSuggestedMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
				}
				else if (InOutMode == EHyperTwistTrainingDeliveryMode::Timer
					|| InOutMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
				}
				else if (bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource
					&& InOutMode != EHyperTwistTrainingDeliveryMode::CoachReviewed
					&& InOutMode != EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
				}

				if (bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffSource)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				else if (bAlignedTightFollowUpGuidanceOutcomeSource)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				else if (bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				else if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Weighted)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				if ((bDeferredOverflowHandoffSource || bTightMethodDrillRecoveryPlanSource)
					&& InOutSelectionPolicy != EHyperTwistTrainingSelectionPolicy::Scripted)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				return;
			}
		}

		if (CoachMemorySnapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
			&& !CoachBrief.bNeedsCoachReview
			&& CoachBrief.FollowUpDepth <= 0)
		{
			if (bDeferredOverflowHandoffSource)
			{
				if (CoachBrief.bPreferRecognitionReplayReview
					&& CoachMemorySnapshot.DominantCoachSuggestedMode
						== EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
				}
				else if (InOutMode == EHyperTwistTrainingDeliveryMode::Timer
					|| InOutMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
				}

				if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Weighted)
				{
					InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
				}
				return;
			}
			if (bBroadMethodDrillRecoveryPlanSource || bAlignedBroadRecommendedGuidanceOutcomeSource)
			{
				if (CoachBrief.bPreferRecognitionReplayReview
					&& CoachMemorySnapshot.DominantCoachSuggestedMode
						== EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
				{
					InOutMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
				}
				else if (InOutMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
					&& CoachMemorySnapshot.DominantCoachSuggestedMode
						!= EHyperTwistTrainingDeliveryMode::CoachReviewed)
				{
					InOutMode = CoachMemorySnapshot.DominantCoachSuggestedMode;
				}

				if (bBroadMethodDrillRecoveryStructureHandoffSource)
				{
					if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
					{
						InOutSelectionPolicy =
							CoachMemorySnapshot.DominantCoachSelectionPolicy
									!= EHyperTwistTrainingSelectionPolicy::Scripted
								? CoachMemorySnapshot.DominantCoachSelectionPolicy
								: EHyperTwistTrainingSelectionPolicy::Weighted;
					}
				}
				else if (bAlignedBroadRecommendedGuidanceOutcomeSource)
				{
					InOutSelectionPolicy =
						CoachMemorySnapshot.DominantCoachSelectionPolicy
								!= EHyperTwistTrainingSelectionPolicy::Scripted
							? CoachMemorySnapshot.DominantCoachSelectionPolicy
							: EHyperTwistTrainingSelectionPolicy::Weighted;
				}
				else if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
				{
					InOutSelectionPolicy =
						CoachMemorySnapshot.DominantCoachSelectionPolicy
								!= EHyperTwistTrainingSelectionPolicy::Scripted
							? CoachMemorySnapshot.DominantCoachSelectionPolicy
							: EHyperTwistTrainingSelectionPolicy::Weighted;
				}
				return;
			}

			if (CoachBrief.bPreferRecognitionReplayReview
				&& CoachMemorySnapshot.DominantCoachSuggestedMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
			{
				InOutMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
			}
			else if (InOutMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
				&& CoachMemorySnapshot.DominantCoachSuggestedMode != EHyperTwistTrainingDeliveryMode::CoachReviewed)
			{
				InOutMode = CoachMemorySnapshot.DominantCoachSuggestedMode;
			}

			if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted
				&& CoachMemorySnapshot.DominantCoachSelectionPolicy != EHyperTwistTrainingSelectionPolicy::Scripted)
			{
				InOutSelectionPolicy = CoachMemorySnapshot.DominantCoachSelectionPolicy;
			}
			return;
		}

		if (CoachMemorySnapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp)
		{
			const bool bShouldBiasFollowUpDefaults =
				CoachBrief.FollowUpDepth > 0
				|| CoachBrief.bNeedsCoachReview
				|| CoachMemorySnapshot.FollowUpReadyCoachSequenceCount > 0
				|| CoachMemorySnapshot.ScheduleBlockedFollowUpEventCount > 0
				|| bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource
				|| bAlignedTightFollowUpGuidanceOutcomeSource;
			if (!bShouldBiasFollowUpDefaults)
			{
				return;
			}

			if (CoachBrief.bPreferRecognitionReplayReview
				&& CoachMemorySnapshot.DominantCoachSuggestedMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
			{
				InOutMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
			}
			else if (InOutMode == EHyperTwistTrainingDeliveryMode::Timer
				|| InOutMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
			{
				InOutMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
			}
			else if (bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource
				&& InOutMode != EHyperTwistTrainingDeliveryMode::CoachReviewed
				&& InOutMode != EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
			{
				InOutMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
			}

			if (bAlignedTightFollowUpGuidanceOutcomeSource)
			{
				InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
			}
			else if (bReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffSource)
			{
				InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
			}
			else if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Weighted)
			{
				InOutSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
			}
			return;
		}

		if (CoachMemorySnapshot.PreferredGuidanceLane != EHyperTwistTrainingCoachGuidanceLane::Recommended
			|| CoachBrief.bNeedsCoachReview
			|| CoachBrief.FollowUpDepth > 0)
		{
			return;
		}

		if (CoachBrief.bPreferRecognitionReplayReview
			&& CoachMemorySnapshot.DominantCoachSuggestedMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
		{
			InOutMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
		}
		else if (bReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffSource
			&& CoachMemorySnapshot.DominantCoachSuggestedMode
				!= EHyperTwistTrainingDeliveryMode::CoachReviewed)
		{
			InOutMode = CoachMemorySnapshot.DominantCoachSuggestedMode;
		}
		else if (InOutMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& CoachMemorySnapshot.DominantCoachSuggestedMode != EHyperTwistTrainingDeliveryMode::CoachReviewed)
		{
			InOutMode = CoachMemorySnapshot.DominantCoachSuggestedMode;
		}

		if (bAlignedBroadRecommendedGuidanceOutcomeSource)
		{
			InOutSelectionPolicy =
				CoachMemorySnapshot.DominantCoachSelectionPolicy != EHyperTwistTrainingSelectionPolicy::Scripted
					? CoachMemorySnapshot.DominantCoachSelectionPolicy
					: EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		else if (bReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffSource)
		{
			InOutSelectionPolicy =
				CoachMemorySnapshot.DominantCoachSelectionPolicy != EHyperTwistTrainingSelectionPolicy::Scripted
					? CoachMemorySnapshot.DominantCoachSelectionPolicy
					: EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		else if (bReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffSource)
		{
			InOutSelectionPolicy =
				CoachMemorySnapshot.DominantCoachSelectionPolicy != EHyperTwistTrainingSelectionPolicy::Scripted
					? CoachMemorySnapshot.DominantCoachSelectionPolicy
					: EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		else if (InOutSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted
			&& CoachMemorySnapshot.DominantCoachSelectionPolicy != EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			InOutSelectionPolicy = CoachMemorySnapshot.DominantCoachSelectionPolicy;
		}
	}

	bool ContainsLaunchBudgetBroadeningHint(const FString& ReasonLine)
	{
		return ReasonLine.Contains(TEXT("broaden"), ESearchCase::IgnoreCase)
			|| ReasonLine.Contains(TEXT("widen"), ESearchCase::IgnoreCase);
	}

	bool ContainsLaunchBudgetTighteningHint(const FString& ReasonLine)
	{
		return ReasonLine.Contains(TEXT("tight"), ESearchCase::IgnoreCase)
			|| ReasonLine.Contains(TEXT("narrow"), ESearchCase::IgnoreCase);
	}

	EHyperTwistTrainingCoachGuidanceLane GuidanceLaneFromQueueSourceLabel(const FString& SourceLabel)
	{
		if (SourceLabel == TEXT("follow-up-brief"))
		{
			return EHyperTwistTrainingCoachGuidanceLane::FollowUp;
		}
		if (SourceLabel == TEXT("primary-brief"))
		{
			return EHyperTwistTrainingCoachGuidanceLane::Recommended;
		}

		return EHyperTwistTrainingCoachGuidanceLane::None;
	}

	EHyperTwistTrainingCoachGuidanceLane GuidanceLaneFromQueueEntry(
		const FHyperTwistTrainingCoachSessionQueueStateEntry* Entry)
	{
		if (Entry == nullptr)
		{
			return EHyperTwistTrainingCoachGuidanceLane::None;
		}
		if (Entry->bRequiresFollowUp)
		{
			return EHyperTwistTrainingCoachGuidanceLane::FollowUp;
		}

		return GuidanceLaneFromQueueSourceLabel(Entry->SourceLabel);
	}

	const FHyperTwistTrainingCoachSessionQueueStateEntry* FindQueueEntryById(
		const FHyperTwistTrainingCoachSessionQueueState& QueueState,
		const FString& EntryId)
	{
		return QueueState.Entries.FindByPredicate(
			[&EntryId](const FHyperTwistTrainingCoachSessionQueueStateEntry& Candidate)
			{
				return Candidate.EntryId == EntryId;
			}
		);
	}

	int32 ComputePlanDurationMs(
		const FHyperTwistTrainingReviewPlanState& ReviewPlan,
		const FString& ReferenceUtc
	)
	{
		const FString StartUtc = ResolvePlanStartUtc(ReviewPlan);
		if (StartUtc.IsEmpty())
		{
			return 0;
		}

		const FString EndUtc = !ReviewPlan.CompletedAtUtc.IsEmpty()
			? ReviewPlan.CompletedAtUtc
			: ResolveReferenceUtc(ReferenceUtc);
		return ComputeElapsedMilliseconds(StartUtc, EndUtc);
	}

	double ComputeRetrievability(const FHyperTwistTrainingCaseLearnerState& CurrentState, const FString& ReviewedAtUtc)
	{
		if (CurrentState.LastReviewedAtUtc.IsEmpty())
		{
			return 1.0;
		}

		const double ElapsedDays = ComputeElapsedDays(CurrentState.LastReviewedAtUtc, ReviewedAtUtc);
		return FMath::Pow(1.0 + ElapsedDays / FMath::Max(0.01, 9.0 * static_cast<double>(CurrentState.StabilityDays)), -1.0);
	}

	double GetMedianMetric(
		const TArray<FHyperTwistTrainingReviewHistoryEntry>& ReviewHistory,
		int32 FHyperTwistTrainingReviewHistoryEntry::* MetricMember
	)
	{
		TArray<double> Values;
		for (const FHyperTwistTrainingReviewHistoryEntry& Entry : ReviewHistory)
		{
			const int32 MetricValue = Entry.*MetricMember;
			if (IsSuccessfulReview(Entry) && MetricValue > 0)
			{
				Values.Add(static_cast<double>(MetricValue));
			}
		}

		if (Values.Num() < 3)
		{
			return -1.0;
		}

		if (Values.Num() > ReviewBaselineSampleSize)
		{
			const int32 TrimCount = Values.Num() - ReviewBaselineSampleSize;
			Values.RemoveAt(0, TrimCount, EAllowShrinking::No);
		}

		Values.Sort();
		const int32 MiddleIndex = Values.Num() / 2;
		if (Values.Num() % 2 == 1)
		{
			return Values[MiddleIndex];
		}

		return (Values[MiddleIndex - 1] + Values[MiddleIndex]) * 0.5;
	}

	bool IsMuchSlower(int32 CurrentValue, double BaselineValue)
	{
		return CurrentValue > 0
			&& BaselineValue > 0.0
			&& static_cast<double>(CurrentValue) > BaselineValue * MuchSlowerThreshold;
	}

	int32 DeriveAutoLearnedLevel(const TArray<FHyperTwistTrainingReviewHistoryEntry>& ReviewHistory)
	{
		if (ReviewHistory.Num() < AutoLearningMinReviews)
		{
			return 0;
		}

		const int32 StartIndex = FMath::Max(0, ReviewHistory.Num() - AutoLearningWindow);
		int32 SuccessCount = 0;
		for (int32 Index = StartIndex; Index < ReviewHistory.Num(); ++Index)
		{
			if (IsSuccessfulReview(ReviewHistory[Index]))
			{
				SuccessCount += 1;
			}
		}

		return ReviewHistory.Num() - StartIndex >= AutoLearningWindow && SuccessCount >= AutoLearningMinSuccesses ? 2 : 1;
	}

	bool ShouldThrottleUpwardGrowth(const FHyperTwistTrainingCaseLearnerState& CurrentState, const FString& ReviewedAtUtc)
	{
		return ComputeElapsedMilliseconds(CurrentState.LastReviewedAtUtc, ReviewedAtUtc) < UpwardGrowthThrottleMs;
	}

	FString MakeCaseKey(const FString& UserId, const FString& DeckId, const FString& CaseId)
	{
		return UserId + CaseKeySeparator + DeckId + CaseKeySeparator + CaseId;
	}

	FString MakeTemplateKey(const FString& UserId, const FString& TemplateId)
	{
		return UserId + CaseKeySeparator + TemplateId;
	}

	FString MakeMethodDrillFavoriteKey(
		const FString& UserId,
		const FString& DrillId,
		const FString& CaseId
	)
	{
		return UserId + CaseKeySeparator + DrillId + CaseKeySeparator + CaseId;
	}

	FString MakeMethodDrillBatchKey(const FString& UserId, const FString& BatchId)
	{
		return UserId + CaseKeySeparator + BatchId;
	}

	FString MakeCoachActionPlanKey(const FString& UserId, const FString& PlanId)
	{
		return UserId + CaseKeySeparator + PlanId;
	}

	FString MakeCoachSessionQueueKey(const FString& UserId, const FString& QueueId)
	{
		return UserId + CaseKeySeparator + QueueId;
	}

	TArray<FString> DeduplicateCaseIds(const TArray<FString>& CaseIds)
	{
		TArray<FString> UniqueCaseIds;
		for (const FString& CaseId : CaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				UniqueCaseIds.AddUnique(CaseId);
			}
		}

		return UniqueCaseIds;
	}

	TArray<FString> ResolveCoachActionPlanFocusCaseIds(
		const FHyperTwistCoachBrief& CoachBrief,
		const TArray<FString>& LaunchedCaseIds,
		const int32 PlannedLaunchCaseCount)
	{
		TArray<FString> ResolvedCaseIds = DeduplicateCaseIds(
			LaunchedCaseIds.Num() > 0 ? LaunchedCaseIds : CoachBrief.FocusCaseIds
		);
		if (LaunchedCaseIds.Num() == 0
			&& PlannedLaunchCaseCount > 0
			&& ResolvedCaseIds.Num() > PlannedLaunchCaseCount)
		{
			ResolvedCaseIds.SetNum(PlannedLaunchCaseCount);
		}

		return ResolvedCaseIds;
	}

	TArray<FHyperTwistTrainingMethodDrillResponseRecord> DeduplicateMethodDrillResponses(
		const TArray<FHyperTwistTrainingMethodDrillResponseRecord>& Responses
	)
	{
		TArray<FHyperTwistTrainingMethodDrillResponseRecord> UniqueResponses;
		TSet<FString> SeenResponseIds;
		for (const FHyperTwistTrainingMethodDrillResponseRecord& Response : Responses)
		{
			if (!Response.IsStructurallyValid() || SeenResponseIds.Contains(Response.ResponseId))
			{
				continue;
			}

			SeenResponseIds.Add(Response.ResponseId);
			UniqueResponses.Add(Response);
		}

		return UniqueResponses;
	}

	bool SplitCaseKey(const FString& CaseKey, FString& OutUserId, FString& OutDeckId, FString& OutCaseId)
	{
		TArray<FString> Parts;
		CaseKey.ParseIntoArray(Parts, CaseKeySeparator, false);
		if (Parts.Num() != 3)
		{
			OutUserId.Reset();
			OutDeckId.Reset();
			OutCaseId.Reset();
			return false;
		}

		OutUserId = Parts[0];
		OutDeckId = Parts[1];
		OutCaseId = Parts[2];
		return true;
	}

	void AppendRepairAction(TArray<FString>& RepairActions, const FString& Action)
	{
		if (!Action.IsEmpty())
		{
			RepairActions.AddUnique(Action);
		}
	}

	template <typename TStruct>
	FString SerializeStructToJson(const TStruct& Value)
	{
		FString Json;
		FJsonObjectConverter::UStructToJsonObjectString(TStruct::StaticStruct(), &Value, Json, 0, 0);
		return Json;
	}

	template <typename TStruct>
	bool DoSerializedStructsMatch(const TStruct& Left, const TStruct& Right)
	{
		return SerializeStructToJson(Left) == SerializeStructToJson(Right);
	}

	TArray<FHyperTwistTrainingCaseLearnerState> NormalizeLearnerStates(
		const TArray<FHyperTwistTrainingCaseLearnerState>& LearnerStates
	)
	{
		TArray<FHyperTwistTrainingCaseLearnerState> NormalizedStates;
		TMap<FString, int32> LearnerStateIndexByKey;
		for (const FHyperTwistTrainingCaseLearnerState& LearnerState : LearnerStates)
		{
			if (!LearnerState.IsStructurallyValid())
			{
				continue;
			}

			const FString LearnerStateKey = MakeCaseKey(
				LearnerState.UserId,
				LearnerState.DeckId,
				LearnerState.CaseId
			);
			if (const int32* ExistingIndex = LearnerStateIndexByKey.Find(LearnerStateKey))
			{
				NormalizedStates[*ExistingIndex] = LearnerState;
			}
			else
			{
				LearnerStateIndexByKey.Add(LearnerStateKey, NormalizedStates.Add(LearnerState));
			}
		}

		NormalizedStates.Sort([](
			const FHyperTwistTrainingCaseLearnerState& Left,
			const FHyperTwistTrainingCaseLearnerState& Right
		)
		{
			if (Left.UserId != Right.UserId)
			{
				return Left.UserId < Right.UserId;
			}
			if (Left.DeckId != Right.DeckId)
			{
				return Left.DeckId < Right.DeckId;
			}
			return Left.CaseId < Right.CaseId;
		});
		return NormalizedStates;
	}

	bool IsTerminalReviewPlanEntryState(const EHyperTwistTrainingReviewPlanEntryState EntryState)
	{
		return EntryState == EHyperTwistTrainingReviewPlanEntryState::Completed
			|| EntryState == EHyperTwistTrainingReviewPlanEntryState::Skipped;
	}

	FHyperTwistTrainingReviewPlanEntry NormalizeReviewPlanEntry(
		const FHyperTwistTrainingReviewPlanEntry& Entry
	)
	{
		FHyperTwistTrainingReviewPlanEntry NormalizedEntry = Entry;
		NormalizedEntry.AttemptCount = FMath::Max(0, NormalizedEntry.AttemptCount);
		NormalizedEntry.SuccessCount = FMath::Clamp(
			NormalizedEntry.SuccessCount,
			0,
			NormalizedEntry.AttemptCount
		);
		if (NormalizedEntry.PromptLabel.IsEmpty())
		{
			NormalizedEntry.PromptLabel = NormalizedEntry.CaseId;
		}

		return NormalizedEntry;
	}

	FHyperTwistTrainingReviewPlanState NormalizeReviewPlanState(
		const FHyperTwistTrainingReviewPlanState& ReviewPlan
	)
	{
		FHyperTwistTrainingReviewPlanState NormalizedPlan = ReviewPlan;
		const FString ReferenceSeed = !ReviewPlan.ReferenceUtc.IsEmpty()
			? ReviewPlan.ReferenceUtc
			: (!ReviewPlan.CreatedAtUtc.IsEmpty()
				? ReviewPlan.CreatedAtUtc
				: (!ReviewPlan.StartedAtUtc.IsEmpty() ? ReviewPlan.StartedAtUtc : ReviewPlan.CompletedAtUtc));
		NormalizedPlan.ReferenceUtc = ResolveReferenceUtc(ReferenceSeed);
		if (NormalizedPlan.CreatedAtUtc.IsEmpty())
		{
			NormalizedPlan.CreatedAtUtc = NormalizedPlan.ReferenceUtc;
		}
		if (NormalizedPlan.StartedAtUtc.IsEmpty())
		{
			NormalizedPlan.StartedAtUtc = NormalizedPlan.CreatedAtUtc;
		}
		NormalizedPlan.Policy.MaxCases = FMath::Max(0, NormalizedPlan.Policy.MaxCases);

		TMap<FString, int32> EntryIndexByCaseId;
		TArray<FHyperTwistTrainingReviewPlanEntry> NormalizedEntries;
		for (const FHyperTwistTrainingReviewPlanEntry& Entry : ReviewPlan.Entries)
		{
			const FHyperTwistTrainingReviewPlanEntry NormalizedEntry = NormalizeReviewPlanEntry(Entry);
			if (!NormalizedEntry.IsStructurallyValid())
			{
				continue;
			}

			if (const int32* ExistingIndex = EntryIndexByCaseId.Find(NormalizedEntry.CaseId))
			{
				NormalizedEntries[*ExistingIndex] = NormalizedEntry;
			}
			else
			{
				EntryIndexByCaseId.Add(NormalizedEntry.CaseId, NormalizedEntries.Add(NormalizedEntry));
			}
		}

		NormalizedPlan.Entries = NormalizedEntries;
		if (!NormalizedPlan.IsStructurallyValid())
		{
			NormalizedPlan.CurrentEntryIndex = INDEX_NONE;
			return NormalizedPlan;
		}

		int32 ResolvedCurrentEntryIndex = INDEX_NONE;
		if (!NormalizedPlan.bCompleted
			&& NormalizedPlan.Entries.IsValidIndex(NormalizedPlan.CurrentEntryIndex)
			&& !IsTerminalReviewPlanEntryState(
				NormalizedPlan.Entries[NormalizedPlan.CurrentEntryIndex].EntryState))
		{
			ResolvedCurrentEntryIndex = NormalizedPlan.CurrentEntryIndex;
		}
		if (ResolvedCurrentEntryIndex == INDEX_NONE && !NormalizedPlan.bCompleted)
		{
			ResolvedCurrentEntryIndex = NormalizedPlan.Entries.IndexOfByPredicate(
				[](const FHyperTwistTrainingReviewPlanEntry& Entry)
				{
					return Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::Current;
				}
			);
			if (ResolvedCurrentEntryIndex >= 0
				&& IsTerminalReviewPlanEntryState(
					NormalizedPlan.Entries[ResolvedCurrentEntryIndex].EntryState))
			{
				ResolvedCurrentEntryIndex = INDEX_NONE;
			}
		}
		if (ResolvedCurrentEntryIndex == INDEX_NONE && !NormalizedPlan.bCompleted)
		{
			ResolvedCurrentEntryIndex = NormalizedPlan.Entries.IndexOfByPredicate(
				[](const FHyperTwistTrainingReviewPlanEntry& Entry)
				{
					return Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::NeedsRepeat
						|| Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::Pending;
				}
			);
		}

		int32 TerminalCount = 0;
		FString LatestCompletedAtUtc;
		for (const FHyperTwistTrainingReviewPlanEntry& Entry : NormalizedPlan.Entries)
		{
			if (IsTerminalReviewPlanEntryState(Entry.EntryState))
			{
				TerminalCount += 1;
			}
			if (!Entry.LastCompletedAtUtc.IsEmpty()
				&& (LatestCompletedAtUtc.IsEmpty()
					|| CompareUtcStrings(Entry.LastCompletedAtUtc, LatestCompletedAtUtc) > 0))
			{
				LatestCompletedAtUtc = Entry.LastCompletedAtUtc;
			}
		}
		if (TerminalCount >= NormalizedPlan.Entries.Num())
		{
			NormalizedPlan.bCompleted = true;
		}

		if (NormalizedPlan.bCompleted)
		{
			NormalizedPlan.CurrentEntryIndex = INDEX_NONE;
			for (FHyperTwistTrainingReviewPlanEntry& Entry : NormalizedPlan.Entries)
			{
				if (Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::Current)
				{
					Entry.EntryState = Entry.LastOutcome == EHyperTwistTrainingAttemptResult::Aborted
						? EHyperTwistTrainingReviewPlanEntryState::Skipped
						: (Entry.SuccessCount > 0
							? EHyperTwistTrainingReviewPlanEntryState::Completed
							: (Entry.AttemptCount > 0
								? EHyperTwistTrainingReviewPlanEntryState::NeedsRepeat
								: EHyperTwistTrainingReviewPlanEntryState::Pending));
				}
			}
			if (NormalizedPlan.CompletedAtUtc.IsEmpty())
			{
				NormalizedPlan.CompletedAtUtc = !LatestCompletedAtUtc.IsEmpty()
					? LatestCompletedAtUtc
					: ResolveReferenceUtc(
						!NormalizedPlan.StartedAtUtc.IsEmpty()
							? NormalizedPlan.StartedAtUtc
							: NormalizedPlan.ReferenceUtc
					);
			}
			return NormalizedPlan;
		}

		NormalizedPlan.CompletedAtUtc.Reset();
		NormalizedPlan.CurrentEntryIndex = ResolvedCurrentEntryIndex;
		for (int32 EntryIndex = 0; EntryIndex < NormalizedPlan.Entries.Num(); ++EntryIndex)
		{
			FHyperTwistTrainingReviewPlanEntry& Entry = NormalizedPlan.Entries[EntryIndex];
			if (IsTerminalReviewPlanEntryState(Entry.EntryState))
			{
				continue;
			}

			if (EntryIndex == ResolvedCurrentEntryIndex)
			{
				Entry.EntryState = EHyperTwistTrainingReviewPlanEntryState::Current;
				continue;
			}

			if (Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::Current)
			{
				Entry.EntryState = Entry.LastOutcome == EHyperTwistTrainingAttemptResult::Aborted
					? EHyperTwistTrainingReviewPlanEntryState::Skipped
					: (Entry.AttemptCount > 0
						? EHyperTwistTrainingReviewPlanEntryState::NeedsRepeat
						: EHyperTwistTrainingReviewPlanEntryState::Pending);
			}
		}

		return NormalizedPlan;
	}

	FHyperTwistTrainingMethodDrillFavoriteEntry NormalizeMethodDrillFavoriteEntry(
		const FHyperTwistTrainingMethodDrillFavoriteEntry& FavoriteEntry
	)
	{
		FHyperTwistTrainingMethodDrillFavoriteEntry NormalizedFavorite = FavoriteEntry;
		NormalizedFavorite.Tags = DeduplicateTemplateCaseIds(FavoriteEntry.Tags);
		NormalizedFavorite.Tags.AddUnique(TEXT("favorite"));
		if (NormalizedFavorite.AddedAtUtc.IsEmpty())
		{
			NormalizedFavorite.AddedAtUtc = FDateTime::UtcNow().ToIso8601();
		}

		return NormalizedFavorite;
	}

	FHyperTwistTrainingMethodDrillBatch NormalizeMethodDrillBatch(
		const FHyperTwistTrainingMethodDrillBatch& DrillBatch
	)
	{
		FHyperTwistTrainingMethodDrillBatch NormalizedBatch = DrillBatch;
		NormalizedBatch.PendingCaseIds = DeduplicateCaseIds(DrillBatch.PendingCaseIds);
		NormalizedBatch.CompletedCaseIds = DeduplicateCaseIds(DrillBatch.CompletedCaseIds);
		if (!NormalizedBatch.CurrentCaseId.IsEmpty())
		{
			NormalizedBatch.CompletedCaseIds.Remove(NormalizedBatch.CurrentCaseId);
		}
		NormalizedBatch.Responses = DeduplicateMethodDrillResponses(DrillBatch.Responses);
		if (NormalizedBatch.CreatedAtUtc.IsEmpty())
		{
			NormalizedBatch.CreatedAtUtc = FDateTime::UtcNow().ToIso8601();
		}
		if (NormalizedBatch.LastUpdatedAtUtc.IsEmpty())
		{
			NormalizedBatch.LastUpdatedAtUtc = NormalizedBatch.CreatedAtUtc;
		}

		return NormalizedBatch;
	}

	FHyperTwistTrainingCoachActionPlan NormalizeCoachActionPlan(
		const FHyperTwistTrainingCoachActionPlan& ActionPlan
	)
	{
		FHyperTwistTrainingCoachActionPlan NormalizedPlan = ActionPlan;
		NormalizedPlan.ReferenceUtc = ResolveReferenceUtc(NormalizedPlan.ReferenceUtc);
		NormalizedPlan.FocusCaseIds = DeduplicateTemplateCaseIds(NormalizedPlan.FocusCaseIds);
		NormalizedPlan.DeferredLaunchCaseIds = DeduplicateCaseIds(NormalizedPlan.DeferredLaunchCaseIds);
		if (NormalizedPlan.CreatedAtUtc.IsEmpty())
		{
			NormalizedPlan.CreatedAtUtc = NormalizedPlan.ReferenceUtc;
		}

		TMap<FString, int32> EntryIndexById;
		TArray<FHyperTwistTrainingCoachActionPlanEntry> NormalizedEntries;
		for (const FHyperTwistTrainingCoachActionPlanEntry& Entry : ActionPlan.Entries)
		{
			if (!Entry.IsStructurallyValid())
			{
				continue;
			}

			if (const int32* ExistingIndex = EntryIndexById.Find(Entry.ActionId))
			{
				NormalizedEntries[*ExistingIndex] = Entry;
			}
			else
			{
				EntryIndexById.Add(Entry.ActionId, NormalizedEntries.Add(Entry));
			}
		}

		NormalizedEntries.Sort([](
			const FHyperTwistTrainingCoachActionPlanEntry& Left,
			const FHyperTwistTrainingCoachActionPlanEntry& Right
		)
		{
			if (!FMath::IsNearlyEqual(Left.PriorityScore, Right.PriorityScore))
			{
				return Left.PriorityScore > Right.PriorityScore;
			}

			return Left.ActionId < Right.ActionId;
		});
		NormalizedPlan.Entries = NormalizedEntries;

		if (NormalizedPlan.FocusDeckId.IsEmpty() && NormalizedPlan.Entries.Num() > 0)
		{
			NormalizedPlan.FocusDeckId = NormalizedPlan.Entries[0].DeckId;
		}
		if (NormalizedPlan.FocusMethodSegmentId.IsEmpty() && NormalizedPlan.Entries.Num() > 0)
		{
			NormalizedPlan.FocusMethodSegmentId = NormalizedPlan.Entries[0].MethodSegmentId;
		}
		if (NormalizedPlan.Headline.IsEmpty())
		{
			NormalizedPlan.Headline = NormalizedPlan.PrimaryActionLabel;
		}
		if (NormalizedPlan.FollowUpDepth < 0)
		{
			NormalizedPlan.FollowUpDepth = 0;
		}
		if (NormalizedPlan.ParentPlanId.IsEmpty())
		{
			NormalizedPlan.FollowUpDepth = 0;
		}
		if (NormalizedPlan.RootPlanId.IsEmpty())
		{
			NormalizedPlan.RootPlanId = NormalizedPlan.ParentPlanId.IsEmpty()
				? NormalizedPlan.PlanId
				: NormalizedPlan.ParentPlanId;
		}

		return NormalizedPlan;
	}

	struct FCoachActionPlanLineageAnalysis
	{
		FString ActualRootPlanId;
		int32 ActualDepth = 0;
		bool bMissingImmediateParent = false;
		bool bMissingHigherAncestor = false;
		bool bDetectedCycle = false;
		bool bRootMismatch = false;
		bool bDepthMismatch = false;
	};

	FCoachActionPlanLineageAnalysis AnalyzeCoachActionPlanLineage(
		const FHyperTwistTrainingCoachActionPlan& ActionPlan,
		const TArray<FHyperTwistTrainingCoachActionPlan>& ActionPlans,
		const TMap<FString, int32>& ActionPlanIndexByKey
	)
	{
		FCoachActionPlanLineageAnalysis Analysis;
		Analysis.ActualRootPlanId = ActionPlan.PlanId;
		Analysis.ActualDepth = 0;
		if (ActionPlan.ParentPlanId.IsEmpty())
		{
			Analysis.bRootMismatch =
				!ActionPlan.RootPlanId.IsEmpty() && ActionPlan.RootPlanId != Analysis.ActualRootPlanId;
			Analysis.bDepthMismatch = ActionPlan.FollowUpDepth != 0;
			return Analysis;
		}

		if (ActionPlan.ParentPlanId == ActionPlan.PlanId)
		{
			Analysis.bMissingImmediateParent = true;
			Analysis.bDetectedCycle = true;
			Analysis.bRootMismatch =
				!ActionPlan.RootPlanId.IsEmpty() && ActionPlan.RootPlanId != Analysis.ActualRootPlanId;
			Analysis.bDepthMismatch = ActionPlan.FollowUpDepth != 0;
			return Analysis;
		}

		const FString ParentKey = MakeCoachActionPlanKey(ActionPlan.UserId, ActionPlan.ParentPlanId);
		const int32* ParentIndex = ActionPlanIndexByKey.Find(ParentKey);
		if (ParentIndex == nullptr || !ActionPlans.IsValidIndex(*ParentIndex))
		{
			Analysis.bMissingImmediateParent = true;
			Analysis.bRootMismatch =
				!ActionPlan.RootPlanId.IsEmpty() && ActionPlan.RootPlanId != Analysis.ActualRootPlanId;
			Analysis.bDepthMismatch = ActionPlan.FollowUpDepth != 0;
			return Analysis;
		}

		const FHyperTwistTrainingCoachActionPlan* CurrentPlan = &ActionPlans[*ParentIndex];
		Analysis.ActualRootPlanId = CurrentPlan->PlanId;
		Analysis.ActualDepth = 1;

		TSet<FString> VisitedPlanIds;
		VisitedPlanIds.Add(ActionPlan.PlanId);
		VisitedPlanIds.Add(CurrentPlan->PlanId);

		for (int32 GuardIndex = 0; GuardIndex < 64; ++GuardIndex)
		{
			if (CurrentPlan->ParentPlanId.IsEmpty())
			{
				break;
			}
			if (CurrentPlan->ParentPlanId == CurrentPlan->PlanId
				|| VisitedPlanIds.Contains(CurrentPlan->ParentPlanId))
			{
				Analysis.bDetectedCycle = true;
				break;
			}

			const FString NextParentKey = MakeCoachActionPlanKey(ActionPlan.UserId, CurrentPlan->ParentPlanId);
			const int32* NextParentIndex = ActionPlanIndexByKey.Find(NextParentKey);
			if (NextParentIndex == nullptr || !ActionPlans.IsValidIndex(*NextParentIndex))
			{
				Analysis.bMissingHigherAncestor = true;
				break;
			}

			CurrentPlan = &ActionPlans[*NextParentIndex];
			VisitedPlanIds.Add(CurrentPlan->PlanId);
			Analysis.ActualRootPlanId = CurrentPlan->PlanId;
			Analysis.ActualDepth += 1;
		}

		Analysis.bRootMismatch =
			!ActionPlan.RootPlanId.IsEmpty() && ActionPlan.RootPlanId != Analysis.ActualRootPlanId;
		Analysis.bDepthMismatch = ActionPlan.FollowUpDepth != Analysis.ActualDepth;
		return Analysis;
	}

	bool IsTerminalCoachQueueEntryState(const EHyperTwistTrainingCoachSessionQueueEntryState EntryState)
	{
		return EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Completed
			|| EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Skipped
			|| EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Expired;
	}

	bool IsUtcDueOrPast(const FString& CandidateUtc, const FString& ReferenceUtc)
	{
		FDateTime CandidateTime;
		FDateTime ReferenceTime;
		if (!TryParseUtc(CandidateUtc, CandidateTime) || !TryParseUtc(ReferenceUtc, ReferenceTime))
		{
			return false;
		}

		return CandidateTime <= ReferenceTime;
	}

	FString MakeCoachSessionQueueEntryFingerprint(
		const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry
	)
	{
		const FString CaseFingerprint = FString::Join(Entry.FocusCaseIds, TEXT("|"));
		TArray<FString> FingerprintParts;
		FingerprintParts.Reserve(22);
		FingerprintParts.Add(Entry.SourceLabel);
		FingerprintParts.Add(Entry.SourceBriefTrainingSessionId);
		FingerprintParts.Add(Entry.SourceReviewPlanId);
		FingerprintParts.Add(Entry.CarryForwardPlanId);
		FingerprintParts.Add(Entry.RootPlanId);
		FingerprintParts.Add(FString::FromInt(Entry.FollowUpDepth));
		FingerprintParts.Add(Entry.FocusLaneLabel);
		FingerprintParts.Add(Entry.Headline);
		FingerprintParts.Add(Entry.PrimaryActionLabel);
		FingerprintParts.Add(Entry.FocusDeckId);
		FingerprintParts.Add(Entry.FocusMethodSegmentId);
		FingerprintParts.Add(FString::FromInt(static_cast<int32>(Entry.SuggestedMode)));
		FingerprintParts.Add(FString::FromInt(static_cast<int32>(Entry.SuggestedSelectionPolicy)));
		FingerprintParts.Add(CaseFingerprint);
		FingerprintParts.Add(FString::FromInt(Entry.DeferredLaunchCaseCount));
		FingerprintParts.Add(Entry.bNeedsDeferredLaunchRecovery ? TEXT("1") : TEXT("0"));
		FingerprintParts.Add(Entry.bHasTightenedLaunchOverflow ? TEXT("1") : TEXT("0"));
		FingerprintParts.Add(Entry.bRequiresFollowUp ? TEXT("1") : TEXT("0"));
		FingerprintParts.Add(Entry.bRequiresArchiveRetentionTuning ? TEXT("1") : TEXT("0"));
		FingerprintParts.Add(Entry.bNeedsCoachReview ? TEXT("1") : TEXT("0"));
		FingerprintParts.Add(Entry.bNeedsCadenceRecovery ? TEXT("1") : TEXT("0"));
		FingerprintParts.Add(Entry.bNeedsVarietyRotation ? TEXT("1") : TEXT("0"));
		FingerprintParts.Add(Entry.bPreferRecognitionReplayReview ? TEXT("1") : TEXT("0"));
		return FString::Join(FingerprintParts, TEXT("|"));
	}

	FHyperTwistTrainingCoachSessionQueueState NormalizeCoachSessionQueueState(
		const FHyperTwistTrainingCoachSessionQueueState& QueueState
	)
	{
		FHyperTwistTrainingCoachSessionQueueState NormalizedState = QueueState;
		if (NormalizedState.QueueId.IsEmpty())
		{
			NormalizedState.QueueId = TEXT("coach_queue_active");
		}

		NormalizedState.ReferenceUtc = ResolveReferenceUtc(NormalizedState.ReferenceUtc);
		NormalizedState.LastUpdatedAtUtc = ResolveReferenceUtc(
			NormalizedState.LastUpdatedAtUtc.IsEmpty()
				? NormalizedState.ReferenceUtc
				: NormalizedState.LastUpdatedAtUtc
		);

		TMap<FString, int32> EntryIndexById;
		TArray<FHyperTwistTrainingCoachSessionQueueStateEntry> NormalizedEntries;
		for (const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : QueueState.Entries)
		{
			FHyperTwistTrainingCoachSessionQueueStateEntry NormalizedEntry = Entry;
			NormalizedEntry.FocusCaseIds = DeduplicateCaseIds(Entry.FocusCaseIds);
			NormalizedEntry.FollowUpDepth = FMath::Max(0, NormalizedEntry.FollowUpDepth);
			NormalizedEntry.DeferredLaunchCaseCount = FMath::Max(0, NormalizedEntry.DeferredLaunchCaseCount);
			if (NormalizedEntry.WorkFingerprint.IsEmpty())
			{
				NormalizedEntry.WorkFingerprint = MakeCoachSessionQueueEntryFingerprint(NormalizedEntry);
			}
			NormalizedEntry.RescheduleCount = FMath::Max(0, NormalizedEntry.RescheduleCount);
			NormalizedEntry.bPinned = NormalizedEntry.bPinned
				|| NormalizedEntry.bRequiresFollowUp
				|| NormalizedEntry.bRequiresArchiveRetentionTuning;
			if (NormalizedEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Deferred
				&& NormalizedEntry.DeferredUntilUtc.IsEmpty())
			{
				NormalizedEntry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
			}
			if (NormalizedEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Deferred
				&& IsUtcDueOrPast(NormalizedEntry.DeferredUntilUtc, NormalizedState.ReferenceUtc))
			{
				NormalizedEntry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
			}
			if (NormalizedEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Ready
				|| NormalizedEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress)
			{
				NormalizedEntry.ScheduledAtUtc = !NormalizedEntry.ScheduledAtUtc.IsEmpty()
					? NormalizedEntry.ScheduledAtUtc
					: NormalizedState.ReferenceUtc;
			}
			if (NormalizedEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Deferred
				|| IsTerminalCoachQueueEntryState(NormalizedEntry.EntryState))
			{
				NormalizedEntry.bCanStartImmediately = false;
			}
			if (!NormalizedEntry.IsStructurallyValid())
			{
				continue;
			}

			if (const int32* ExistingIndex = EntryIndexById.Find(NormalizedEntry.EntryId))
			{
				NormalizedEntries[*ExistingIndex] = NormalizedEntry;
			}
			else
			{
				EntryIndexById.Add(NormalizedEntry.EntryId, NormalizedEntries.Add(NormalizedEntry));
			}
		}

		NormalizedEntries.Sort([](
			const FHyperTwistTrainingCoachSessionQueueStateEntry& Left,
			const FHyperTwistTrainingCoachSessionQueueStateEntry& Right
		)
		{
			if (Left.SlotIndex != Right.SlotIndex)
			{
				return Left.SlotIndex < Right.SlotIndex;
			}
			if (!FMath::IsNearlyEqual(Left.PriorityScore, Right.PriorityScore))
			{
				return Left.PriorityScore > Right.PriorityScore;
			}

			return Left.EntryId < Right.EntryId;
		});

		NormalizedState.ActiveEntryId.Reset();
		NormalizedState.ActiveTrainingSessionId.Reset();
		NormalizedState.PendingEntryCount = 0;
		NormalizedState.DeferredEntryCount = 0;
		NormalizedState.ReadyEntryCount = 0;
		NormalizedState.InProgressEntryCount = 0;
		NormalizedState.CompletedEntryCount = 0;
		NormalizedState.SkippedEntryCount = 0;
		NormalizedState.ExpiredEntryCount = 0;

		bool bHasInProgressEntry = false;
		bool bHasReadyEntry = false;
		for (int32 EntryIndex = 0; EntryIndex < NormalizedEntries.Num(); ++EntryIndex)
		{
			FHyperTwistTrainingCoachSessionQueueStateEntry& Entry = NormalizedEntries[EntryIndex];
			Entry.SlotIndex = EntryIndex;

			if (Entry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress)
			{
				if (bHasInProgressEntry)
				{
					Entry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
					Entry.SourceTrainingSessionId.Reset();
					Entry.StartedAtUtc.Reset();
				}
				else
				{
					bHasInProgressEntry = true;
					Entry.ScheduledAtUtc = !Entry.ScheduledAtUtc.IsEmpty() ? Entry.ScheduledAtUtc : NormalizedState.ReferenceUtc;
					Entry.bCanStartImmediately = false;
					NormalizedState.ActiveEntryId = Entry.EntryId;
					NormalizedState.ActiveTrainingSessionId = Entry.SourceTrainingSessionId;
				}
			}

			if (Entry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Ready)
			{
				if (bHasInProgressEntry || bHasReadyEntry)
				{
					Entry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
					Entry.bCanStartImmediately = false;
				}
				else
				{
					bHasReadyEntry = true;
					Entry.ScheduledAtUtc = !Entry.ScheduledAtUtc.IsEmpty() ? Entry.ScheduledAtUtc : NormalizedState.ReferenceUtc;
					Entry.bCanStartImmediately = true;
					NormalizedState.ActiveEntryId = Entry.EntryId;
				}
			}

			switch (Entry.EntryState)
			{
			case EHyperTwistTrainingCoachSessionQueueEntryState::Pending:
				NormalizedState.PendingEntryCount += 1;
				break;
			case EHyperTwistTrainingCoachSessionQueueEntryState::Deferred:
				NormalizedState.DeferredEntryCount += 1;
				break;
			case EHyperTwistTrainingCoachSessionQueueEntryState::Ready:
				NormalizedState.ReadyEntryCount += 1;
				break;
			case EHyperTwistTrainingCoachSessionQueueEntryState::InProgress:
				NormalizedState.InProgressEntryCount += 1;
				break;
			case EHyperTwistTrainingCoachSessionQueueEntryState::Completed:
				NormalizedState.CompletedEntryCount += 1;
				break;
			case EHyperTwistTrainingCoachSessionQueueEntryState::Skipped:
				NormalizedState.SkippedEntryCount += 1;
				break;
			case EHyperTwistTrainingCoachSessionQueueEntryState::Expired:
				NormalizedState.ExpiredEntryCount += 1;
				break;
			default:
				break;
			}
		}

		if (!bHasInProgressEntry && !bHasReadyEntry)
		{
			for (FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : NormalizedEntries)
			{
				if (Entry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Pending)
				{
					NormalizedState.PendingEntryCount -= 1;
					Entry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Ready;
					Entry.ScheduledAtUtc = !Entry.ScheduledAtUtc.IsEmpty() ? Entry.ScheduledAtUtc : NormalizedState.ReferenceUtc;
					Entry.bCanStartImmediately = true;
					NormalizedState.ReadyEntryCount += 1;
					NormalizedState.ActiveEntryId = Entry.EntryId;
					break;
				}
			}
		}

		NormalizedState.TotalEntryCount = NormalizedEntries.Num();
		NormalizedState.bHasImmediateQueue = NormalizedState.ReadyEntryCount > 0
			|| NormalizedState.InProgressEntryCount > 0;
		NormalizedState.Entries = NormalizedEntries;
		return NormalizedState;
	}

	bool DidCoachSessionQueueEntryChange(
		const FHyperTwistTrainingCoachSessionQueueStateEntry& PreviousEntry,
		const FHyperTwistTrainingCoachSessionQueueStateEntry& CurrentEntry
	)
	{
		return PreviousEntry.WorkFingerprint != CurrentEntry.WorkFingerprint
			|| PreviousEntry.EntryState != CurrentEntry.EntryState
			|| PreviousEntry.ScheduledAtUtc != CurrentEntry.ScheduledAtUtc
			|| PreviousEntry.DeferredUntilUtc != CurrentEntry.DeferredUntilUtc
			|| PreviousEntry.DeferredAtUtc != CurrentEntry.DeferredAtUtc
			|| PreviousEntry.DeferralReasonLabel != CurrentEntry.DeferralReasonLabel
			|| PreviousEntry.StartedAtUtc != CurrentEntry.StartedAtUtc
			|| PreviousEntry.CompletedAtUtc != CurrentEntry.CompletedAtUtc
			|| PreviousEntry.RescheduleCount != CurrentEntry.RescheduleCount
			|| PreviousEntry.SourceTrainingSessionId != CurrentEntry.SourceTrainingSessionId
			|| PreviousEntry.StartActionSourceLabel != CurrentEntry.StartActionSourceLabel
			|| PreviousEntry.bWasManuallyRescheduled != CurrentEntry.bWasManuallyRescheduled;
	}

	EHyperTwistTrainingCoachSessionQueueEventKind DeriveCoachSessionQueueEventKind(
		const FHyperTwistTrainingCoachSessionQueueStateEntry* PreviousEntry,
		const FHyperTwistTrainingCoachSessionQueueStateEntry& CurrentEntry
	)
	{
		if (CurrentEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress)
		{
			return EHyperTwistTrainingCoachSessionQueueEventKind::Started;
		}
		if (CurrentEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Deferred)
		{
			return EHyperTwistTrainingCoachSessionQueueEventKind::Deferred;
		}
		if (CurrentEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Completed)
		{
			return EHyperTwistTrainingCoachSessionQueueEventKind::Completed;
		}
		if (CurrentEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Skipped)
		{
			return EHyperTwistTrainingCoachSessionQueueEventKind::Skipped;
		}
		if (CurrentEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Expired)
		{
			return EHyperTwistTrainingCoachSessionQueueEventKind::Expired;
		}
		if (CurrentEntry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Ready)
		{
			return PreviousEntry != nullptr
				&& PreviousEntry->EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::Deferred
				? EHyperTwistTrainingCoachSessionQueueEventKind::Promoted
				: EHyperTwistTrainingCoachSessionQueueEventKind::Ready;
		}

		return EHyperTwistTrainingCoachSessionQueueEventKind::Queued;
	}

	FString ResolveCoachSessionQueueHistoryEventAtUtc(
		const FHyperTwistTrainingCoachSessionQueueState& QueueState,
		const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry,
		const EHyperTwistTrainingCoachSessionQueueEventKind EventKind
	)
	{
		switch (EventKind)
		{
		case EHyperTwistTrainingCoachSessionQueueEventKind::Started:
			return ResolveReferenceUtc(!Entry.StartedAtUtc.IsEmpty() ? Entry.StartedAtUtc : QueueState.LastUpdatedAtUtc);
		case EHyperTwistTrainingCoachSessionQueueEventKind::Deferred:
			return ResolveReferenceUtc(!Entry.DeferredAtUtc.IsEmpty() ? Entry.DeferredAtUtc : QueueState.LastUpdatedAtUtc);
		case EHyperTwistTrainingCoachSessionQueueEventKind::Completed:
		case EHyperTwistTrainingCoachSessionQueueEventKind::Skipped:
		case EHyperTwistTrainingCoachSessionQueueEventKind::Expired:
			return ResolveReferenceUtc(!Entry.CompletedAtUtc.IsEmpty() ? Entry.CompletedAtUtc : QueueState.LastUpdatedAtUtc);
		case EHyperTwistTrainingCoachSessionQueueEventKind::Promoted:
		case EHyperTwistTrainingCoachSessionQueueEventKind::Ready:
			return ResolveReferenceUtc(!Entry.ScheduledAtUtc.IsEmpty() ? Entry.ScheduledAtUtc : QueueState.LastUpdatedAtUtc);
		default:
			return ResolveReferenceUtc(QueueState.LastUpdatedAtUtc);
		}
	}

	FString MakeCoachSessionQueueHistoryEntryId(
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Entry
	)
	{
		return FString::Printf(
			TEXT("%s|%s|%d|%s|%s|%s|%s"),
			*Entry.QueueId,
			*Entry.EntryId,
			static_cast<int32>(Entry.EventKind),
			*Entry.EventAtUtc,
			*Entry.WorkFingerprint,
			*Entry.SourceTrainingSessionId,
			*Entry.StartActionSourceLabel
		);
	}

	FHyperTwistTrainingCoachSessionQueueHistoryEntry NormalizeCoachSessionQueueHistoryEntry(
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& HistoryEntry
	)
	{
		FHyperTwistTrainingCoachSessionQueueHistoryEntry NormalizedEntry = HistoryEntry;
		NormalizedEntry.EventAtUtc = ResolveReferenceUtc(NormalizedEntry.EventAtUtc);
		NormalizedEntry.FocusCaseIds = DeduplicateCaseIds(NormalizedEntry.FocusCaseIds);
		if (NormalizedEntry.HistoryEntryId.IsEmpty())
		{
			NormalizedEntry.HistoryEntryId = MakeCoachSessionQueueHistoryEntryId(NormalizedEntry);
		}
		return NormalizedEntry;
	}

	FHyperTwistTrainingCoachSessionQueueHistoryEntry BuildCoachSessionQueueHistoryEntry(
		const FHyperTwistTrainingCoachSessionQueueState& QueueState,
		const FHyperTwistTrainingCoachSessionQueueStateEntry& CurrentEntry,
		const FHyperTwistTrainingCoachSessionQueueStateEntry* PreviousEntry
	)
	{
		FHyperTwistTrainingCoachSessionQueueHistoryEntry HistoryEntry;
		HistoryEntry.QueueId = QueueState.QueueId;
		HistoryEntry.UserId = QueueState.UserId;
		HistoryEntry.EntryId = CurrentEntry.EntryId;
		HistoryEntry.SourceLabel = CurrentEntry.SourceLabel;
		HistoryEntry.WorkFingerprint = CurrentEntry.WorkFingerprint;
		HistoryEntry.EventKind = DeriveCoachSessionQueueEventKind(PreviousEntry, CurrentEntry);
		HistoryEntry.EventAtUtc = ResolveCoachSessionQueueHistoryEventAtUtc(
			QueueState,
			CurrentEntry,
			HistoryEntry.EventKind
		);
		HistoryEntry.PreviousEntryState = PreviousEntry != nullptr
			? PreviousEntry->EntryState
			: CurrentEntry.EntryState;
		HistoryEntry.NewEntryState = CurrentEntry.EntryState;
		HistoryEntry.SourceTrainingSessionId = CurrentEntry.SourceTrainingSessionId;
		HistoryEntry.StartActionSourceLabel = CurrentEntry.StartActionSourceLabel;
		HistoryEntry.DeferredUntilUtc = CurrentEntry.DeferredUntilUtc;
		HistoryEntry.DeferralReasonLabel = CurrentEntry.DeferralReasonLabel;
		HistoryEntry.FocusDeckId = CurrentEntry.FocusDeckId;
		HistoryEntry.FocusMethodSegmentId = CurrentEntry.FocusMethodSegmentId;
		HistoryEntry.FocusCaseIds = CurrentEntry.FocusCaseIds;
		HistoryEntry.bRequiresFollowUp = CurrentEntry.bRequiresFollowUp;
		HistoryEntry.bRequiresArchiveRetentionTuning = CurrentEntry.bRequiresArchiveRetentionTuning;
		HistoryEntry.bWasManualReschedule = CurrentEntry.bWasManuallyRescheduled;
		return NormalizeCoachSessionQueueHistoryEntry(HistoryEntry);
	}

	FHyperTwistTrainingCaseLearnerState DeriveLearnerStateFromReviewHistory(
		const FString& UserId,
		const FString& DeckId,
		const FString& CaseId,
		const TArray<FHyperTwistTrainingReviewHistoryEntry>& ReviewHistory
	);

	FHyperTwistTrainingReviewHistoryEntry MakeReviewHistoryEntryFromAttemptHistory(
		const FHyperTwistTrainingAttemptHistoryEntry& AttemptHistoryEntry,
		const TArray<FHyperTwistTrainingReviewHistoryEntry>& ExistingReviewHistory
	)
	{
		FHyperTwistTrainingReviewHistoryEntry ReviewEntry;
		ReviewEntry.AttemptId = AttemptHistoryEntry.AttemptId;
		ReviewEntry.TrainingSessionId = AttemptHistoryEntry.TrainingSessionId;
		ReviewEntry.CaseId = AttemptHistoryEntry.CaseId;
		ReviewEntry.ReviewedAtUtc = AttemptHistoryEntry.RecordedAtUtc;
		ReviewEntry.DeliveryMode = AttemptHistoryEntry.DeliveryMode;
		ReviewEntry.ExecutionTimeMs = AttemptHistoryEntry.ExecutionTimeMs;
		ReviewEntry.RecognitionTimeMs = AttemptHistoryEntry.RecognitionTimeMs;
		ReviewEntry.TotalTimeMs = AttemptHistoryEntry.TotalTimeMs;
		ReviewEntry.bHadMistake = AttemptHistoryEntry.bHadMistake;
		ReviewEntry.bAborted = AttemptHistoryEntry.bAborted;
		ReviewEntry.bTimerOnly = AttemptHistoryEntry.bTimerOnly;
		ReviewEntry.ReplayId = AttemptHistoryEntry.ReplayId;
		ReviewEntry.Grade = UHyperTwistTrainingRepositoryLibrary::DeriveReviewGrade(AttemptHistoryEntry, ExistingReviewHistory);
		return ReviewEntry;
	}

	TMap<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>> BuildReviewHistoryByCase(
		const TArray<FHyperTwistTrainingRunRecord>& RunRecords
	)
	{
		TMap<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>> ReviewHistoryByCase;

		TArray<FHyperTwistTrainingRunRecord> SortedRunRecords = RunRecords;
		SortedRunRecords.Sort([](const FHyperTwistTrainingRunRecord& Left, const FHyperTwistTrainingRunRecord& Right)
		{
			return CompareUtcStrings(Left.LastUpdatedAtUtc, Right.LastUpdatedAtUtc) < 0;
		});

		for (const FHyperTwistTrainingRunRecord& RunRecord : SortedRunRecords)
		{
			if (!RunRecord.IsStructurallyValid())
			{
				continue;
			}

			if (RunRecord.ReviewHistory.Num() > 0)
			{
				TArray<FHyperTwistTrainingReviewHistoryEntry> SortedReviewHistory = RunRecord.ReviewHistory;
				SortedReviewHistory.Sort([](const FHyperTwistTrainingReviewHistoryEntry& Left, const FHyperTwistTrainingReviewHistoryEntry& Right)
				{
					return CompareUtcStrings(Left.ReviewedAtUtc, Right.ReviewedAtUtc) < 0;
				});

				for (const FHyperTwistTrainingReviewHistoryEntry& ReviewEntry : SortedReviewHistory)
				{
					if (!ReviewEntry.IsStructurallyValid())
					{
						continue;
					}

					ReviewHistoryByCase.FindOrAdd(
						MakeCaseKey(RunRecord.Session.UserId, RunRecord.Session.DeckId, ReviewEntry.CaseId)
					).Add(ReviewEntry);
				}

				continue;
			}

			TArray<FHyperTwistTrainingAttemptHistoryEntry> SortedAttemptHistory = RunRecord.AttemptHistory;
			SortedAttemptHistory.Sort([](const FHyperTwistTrainingAttemptHistoryEntry& Left, const FHyperTwistTrainingAttemptHistoryEntry& Right)
			{
				return CompareUtcStrings(Left.RecordedAtUtc, Right.RecordedAtUtc) < 0;
			});

			for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptEntry : SortedAttemptHistory)
			{
				if (!AttemptEntry.IsStructurallyValid())
				{
					continue;
				}

				TArray<FHyperTwistTrainingReviewHistoryEntry>& ExistingHistory = ReviewHistoryByCase.FindOrAdd(
					MakeCaseKey(RunRecord.Session.UserId, RunRecord.Session.DeckId, AttemptEntry.CaseId)
				);
				ExistingHistory.Add(MakeReviewHistoryEntryFromAttemptHistory(AttemptEntry, ExistingHistory));
			}
		}

		return ReviewHistoryByCase;
	}

	TArray<FHyperTwistTrainingCaseLearnerState> DeriveLearnerStatesFromRunRecords(
		const TArray<FHyperTwistTrainingRunRecord>& RunRecords
	)
	{
		TArray<FHyperTwistTrainingCaseLearnerState> LearnerStates;
		const TMap<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>> ReviewHistoryByCase =
			BuildReviewHistoryByCase(RunRecords);
		for (const TPair<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>>& Pair : ReviewHistoryByCase)
		{
			FString UserId;
			FString DeckId;
			FString CaseId;
			if (!SplitCaseKey(Pair.Key, UserId, DeckId, CaseId))
			{
				continue;
			}

			FHyperTwistTrainingCaseLearnerState LearnerState =
				DeriveLearnerStateFromReviewHistory(UserId, DeckId, CaseId, Pair.Value);
			if (LearnerState.IsStructurallyValid())
			{
				LearnerStates.Add(LearnerState);
			}
		}

		LearnerStates.Sort([](
			const FHyperTwistTrainingCaseLearnerState& Left,
			const FHyperTwistTrainingCaseLearnerState& Right
		)
		{
			if (Left.UserId != Right.UserId)
			{
				return Left.UserId < Right.UserId;
			}
			if (Left.DeckId != Right.DeckId)
			{
				return Left.DeckId < Right.DeckId;
			}
			return Left.CaseId < Right.CaseId;
		});
		return LearnerStates;
	}

	FHyperTwistTrainingCaseLearnerState DeriveLearnerStateFromReviewHistory(
		const FString& UserId,
		const FString& DeckId,
		const FString& CaseId,
		const TArray<FHyperTwistTrainingReviewHistoryEntry>& ReviewHistory
	)
	{
		FHyperTwistTrainingCaseLearnerState LearnerState;
		LearnerState.UserId = UserId;
		LearnerState.DeckId = DeckId;
		LearnerState.CaseId = CaseId;

		if (ReviewHistory.Num() == 0)
		{
			return LearnerState;
		}

		int64 TotalTimeAccumulator = 0;
		int32 TimedReviewCount = 0;

		for (int32 ReviewIndex = 0; ReviewIndex < ReviewHistory.Num(); ++ReviewIndex)
		{
			const FHyperTwistTrainingReviewHistoryEntry& ReviewEntry = ReviewHistory[ReviewIndex];
			if (!ReviewEntry.IsStructurallyValid())
			{
				continue;
			}

			if (LearnerState.ReviewCount == 0)
			{
				LearnerState.StabilityDays = static_cast<float>(
					ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Again ? DefaultMinStabilityDays
					: ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Hard ? 1.0
					: ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Easy ? 4.0
					: 2.0
				);
				LearnerState.DifficultyScore = static_cast<float>(
					ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Again ? 6.5
					: ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Hard ? 5.8
					: ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Easy ? 4.2
					: 5.0
				);
				LearnerState.LapseCount = ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Again ? 1 : 0;
			}
			else
			{
				const double Retrievability = ComputeRetrievability(LearnerState, ReviewEntry.ReviewedAtUtc);
				double DifficultyScore = LearnerState.DifficultyScore;
				double StabilityDays = LearnerState.StabilityDays;

				if (ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Again)
				{
					DifficultyScore = MeanRevertDifficulty(DifficultyScore + 1.2);
					StabilityDays = FMath::Max(
						DefaultMinStabilityDays,
						StabilityDays * (0.35 + 0.25 * (1.0 - Retrievability))
					);
					LearnerState.LapseCount += 1;
				}
				else
				{
					const double DifficultyEffect = 1.0 + (10.0 - DifficultyScore) * 0.04;
					const double RetrievabilityEffect = 1.0 + (1.0 - Retrievability) * 2.2;
					const double GradeFactor = ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Hard ? 1.18
						: ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Easy ? 2.8
						: 1.9;
					StabilityDays = FMath::Max(
						StabilityDays,
						StabilityDays * FMath::Max(1.05, GradeFactor * DifficultyEffect * RetrievabilityEffect)
					);
					DifficultyScore = MeanRevertDifficulty(
						DifficultyScore
						+ (ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Hard ? 0.35
							: ReviewEntry.Grade == EHyperTwistTrainingReviewGrade::Easy ? -0.4
							: -0.1)
					);

					if (StabilityDays > LearnerState.StabilityDays
						&& ShouldThrottleUpwardGrowth(LearnerState, ReviewEntry.ReviewedAtUtc))
					{
						StabilityDays = LearnerState.StabilityDays;
					}
				}

				LearnerState.StabilityDays = static_cast<float>(ClampDouble(StabilityDays, DefaultMinStabilityDays, 36500.0));
				LearnerState.DifficultyScore = static_cast<float>(ClampDouble(DifficultyScore, 1.0, 10.0));
			}

			LearnerState.ReviewCount += 1;
			if (IsSuccessfulReview(ReviewEntry))
			{
				LearnerState.SuccessReviewCount += 1;
			}

			if (ReviewEntry.TotalTimeMs > 0)
			{
				TotalTimeAccumulator += ReviewEntry.TotalTimeMs;
				TimedReviewCount += 1;
				if (LearnerState.BestTotalTimeMs == 0 || ReviewEntry.TotalTimeMs < LearnerState.BestTotalTimeMs)
				{
					LearnerState.BestTotalTimeMs = ReviewEntry.TotalTimeMs;
				}
			}

			LearnerState.LastReviewedAtUtc = ReviewEntry.ReviewedAtUtc;
			LearnerState.LastGrade = ReviewEntry.Grade;
		}

		LearnerState.DueAtUtc = AddDaysToUtc(LearnerState.LastReviewedAtUtc, LearnerState.StabilityDays);
		LearnerState.AutoLearnedLevel = DeriveAutoLearnedLevel(ReviewHistory);
		if (TimedReviewCount > 0)
		{
			LearnerState.AverageTotalTimeMs = static_cast<int32>(TotalTimeAccumulator / TimedReviewCount);
		}

		return LearnerState;
	}

	FHyperTwistTrainingCaseRecommendation MakeRecommendationInternal(
		const FHyperTwistTrainingCase& TrainingCase,
		const FHyperTwistTrainingCaseLearnerState& LearnerState,
		const FString& ReferenceUtc
	)
	{
		FHyperTwistTrainingCaseRecommendation Recommendation;
		Recommendation.TrainingCase = TrainingCase;
		Recommendation.LearnerState = LearnerState;
		Recommendation.ReferenceUtc = ResolveReferenceUtc(ReferenceUtc);
		Recommendation.bIsNewCase = !LearnerState.IsStructurallyValid();
		Recommendation.bRequiresReviewFocus = Recommendation.bIsNewCase;

		if (!TrainingCase.IsStructurallyValid())
		{
			return Recommendation;
		}

		const float BaseDifficulty = TrainingCase.Difficulty > 0.0f ? TrainingCase.Difficulty : 1.0f;
		if (Recommendation.bIsNewCase)
		{
			Recommendation.RecommendationScore = 820.0f + BaseDifficulty * 35.0f;
			Recommendation.RecommendationReason = TEXT("new-case");
			Recommendation.bIsDue = true;
			return Recommendation;
		}

		Recommendation.DaysUntilDue = static_cast<float>(ComputeDaysUntilDue(
			LearnerState.DueAtUtc,
			Recommendation.ReferenceUtc
		));
		Recommendation.bIsDue = LearnerState.DueAtUtc.IsEmpty() || Recommendation.DaysUntilDue <= 0.0f;
		Recommendation.bIsOverdue = !LearnerState.DueAtUtc.IsEmpty() && Recommendation.DaysUntilDue < 0.0f;
		Recommendation.bRequiresReviewFocus =
			Recommendation.bIsDue
			|| LearnerState.LastGrade == EHyperTwistTrainingReviewGrade::Again
			|| LearnerState.LastGrade == EHyperTwistTrainingReviewGrade::Hard
			|| LearnerState.AutoLearnedLevel < 2;

		float Score = 0.0f;
		if (Recommendation.bIsOverdue)
		{
			const float OverdueDays = FMath::Abs(Recommendation.DaysUntilDue);
			Score += 1000.0f + OverdueDays * 140.0f;
			Recommendation.RecommendationReason = TEXT("overdue-review");
		}
		else if (Recommendation.bIsDue)
		{
			Score += 760.0f;
			Recommendation.RecommendationReason = TEXT("due-review");
		}
		else
		{
			Score += FMath::Max(0.0f, 260.0f - Recommendation.DaysUntilDue * 40.0f);
			Recommendation.RecommendationReason = TEXT("upcoming-review");
		}

		Score += LearnerState.DifficultyScore * 18.0f;
		Score += static_cast<float>(LearnerState.LapseCount) * 45.0f;
		Score += static_cast<float>(LearnerState.ReviewCount <= 1 ? 80.0f : 0.0f);

		if (LearnerState.LastGrade == EHyperTwistTrainingReviewGrade::Again)
		{
			Score += 220.0f;
		}
		else if (LearnerState.LastGrade == EHyperTwistTrainingReviewGrade::Hard)
		{
			Score += 95.0f;
		}
		else if (LearnerState.LastGrade == EHyperTwistTrainingReviewGrade::Easy)
		{
			Score -= 40.0f;
		}

		if (LearnerState.AutoLearnedLevel >= 2)
		{
			Score -= 80.0f;
		}

		if (LearnerState.AverageTotalTimeMs > 0)
		{
			Score += FMath::Min(150.0f, static_cast<float>(LearnerState.AverageTotalTimeMs) / 1000.0f * 12.0f);
		}

		if (LearnerState.StabilityDays < 1.0f)
		{
			Score += 70.0f;
		}
		else if (LearnerState.StabilityDays >= MatureStabilityDays)
		{
			Score -= 30.0f;
		}

		Recommendation.RecommendationScore = Score;
		return Recommendation;
	}

	int32 ResolvePolicyCaseLimit(const FHyperTwistTrainingReviewPolicy& ReviewPolicy, int32 RequestedMaxCases)
	{
		int32 EffectiveMaxCases = RequestedMaxCases > 0 ? RequestedMaxCases : ReviewPolicy.MaxCases;
		if (EffectiveMaxCases <= 0)
		{
			EffectiveMaxCases = 5;
		}

		if (ReviewPolicy.bPreferShortReviewSets)
		{
			EffectiveMaxCases = FMath::Max(2, FMath::Min(EffectiveMaxCases, ReviewPolicy.MaxCases > 0 ? ReviewPolicy.MaxCases : 4));
		}

		return EffectiveMaxCases;
	}

	struct FScopedStatsAccumulator
	{
		int32 AttemptCount = 0;
		int32 SolveCount = 0;
		int32 SuccessCount = 0;
		int32 FailureCount = 0;
		int32 TimeoutCount = 0;
		int32 DNFCount = 0;
		int32 AbortedCount = 0;
		int32 MistakeAttemptCount = 0;
		int32 Plus2PenaltyCount = 0;
		int32 SmartDeviceAttemptCount = 0;
		int32 SmartDeviceSolveCount = 0;
		int32 RecognitionAttemptCount = 0;
		int32 RecognitionSolveCount = 0;
		int32 BestExecutionTimeMs = 0;
		int32 BestRecognitionTimeMs = 0;
		int32 BestTotalTimeMs = 0;
		int32 BestRawSolveTimeMs = 0;
		int64 ExecutionTimeAccumulator = 0;
		int64 RecognitionTimeAccumulator = 0;
		int64 TotalTimeAccumulator = 0;
		int64 RawSolveTimeAccumulator = 0;
		int64 InspectionTimeAccumulator = 0;
		int32 ExecutionSampleCount = 0;
		int32 RecognitionSampleCount = 0;
		int32 TotalSampleCount = 0;
		int32 RawSolveSampleCount = 0;
		int32 InspectionSampleCount = 0;
		int32 DeliveryModeCounts[5] = {0, 0, 0, 0, 0};
		FString LastAttemptAtUtc;
		FString LastSuccessAtUtc;

		void AddAttempt(const FHyperTwistTrainingAttemptHistoryEntry& AttemptEntry)
		{
			if (!AttemptEntry.IsStructurallyValid())
			{
				return;
			}

			AttemptCount += 1;
			const int32 DeliveryModeIndex = FMath::Clamp(static_cast<int32>(AttemptEntry.DeliveryMode), 0, 4);
			DeliveryModeCounts[DeliveryModeIndex] += 1;

			if (AttemptEntry.bHadMistake)
			{
				MistakeAttemptCount += 1;
			}

			const bool bAbortedAttempt = AttemptEntry.bAborted || AttemptEntry.Result == EHyperTwistTrainingAttemptResult::Aborted;
			if (bAbortedAttempt)
			{
				AbortedCount += 1;
			}
			else
			{
				switch (AttemptEntry.Result)
				{
				case EHyperTwistTrainingAttemptResult::Success:
					SuccessCount += 1;
					break;
				case EHyperTwistTrainingAttemptResult::Failure:
					FailureCount += 1;
					break;
				case EHyperTwistTrainingAttemptResult::Timeout:
					TimeoutCount += 1;
					break;
				case EHyperTwistTrainingAttemptResult::DNF:
					DNFCount += 1;
					break;
				default:
					break;
				}
			}

			if (AttemptEntry.TimingBreakdown.AppliedPenalty == EHyperTwistTrainingPenalty::Plus2)
			{
				Plus2PenaltyCount += 1;
			}

			const bool bHasTimedSolve = !bAbortedAttempt
				&& (AttemptEntry.ExecutionTimeMs > 0 || AttemptEntry.TotalTimeMs > 0 || AttemptEntry.RecognitionTimeMs > 0);
			if (bHasTimedSolve)
			{
				SolveCount += 1;
			}

			if (AttemptEntry.DeliveryMode == EHyperTwistTrainingDeliveryMode::SmartDevice)
			{
				SmartDeviceAttemptCount += 1;
				if (bHasTimedSolve)
				{
					SmartDeviceSolveCount += 1;
				}
			}

			if (AttemptEntry.DeliveryMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted || AttemptEntry.RecognitionTimeMs > 0)
			{
				RecognitionAttemptCount += 1;
				if (bHasTimedSolve)
				{
					RecognitionSolveCount += 1;
				}
			}

			if (AttemptEntry.ExecutionTimeMs > 0)
			{
				ExecutionTimeAccumulator += AttemptEntry.ExecutionTimeMs;
				ExecutionSampleCount += 1;
				if (BestExecutionTimeMs == 0 || AttemptEntry.ExecutionTimeMs < BestExecutionTimeMs)
				{
					BestExecutionTimeMs = AttemptEntry.ExecutionTimeMs;
				}
			}

			if (AttemptEntry.RecognitionTimeMs > 0)
			{
				RecognitionTimeAccumulator += AttemptEntry.RecognitionTimeMs;
				RecognitionSampleCount += 1;
				if (BestRecognitionTimeMs == 0 || AttemptEntry.RecognitionTimeMs < BestRecognitionTimeMs)
				{
					BestRecognitionTimeMs = AttemptEntry.RecognitionTimeMs;
				}
			}

			if (AttemptEntry.TotalTimeMs > 0)
			{
				TotalTimeAccumulator += AttemptEntry.TotalTimeMs;
				TotalSampleCount += 1;
				if (BestTotalTimeMs == 0 || AttemptEntry.TotalTimeMs < BestTotalTimeMs)
				{
					BestTotalTimeMs = AttemptEntry.TotalTimeMs;
				}
			}

			if (AttemptEntry.TimingBreakdown.RawSolveTimeMs > 0)
			{
				RawSolveTimeAccumulator += AttemptEntry.TimingBreakdown.RawSolveTimeMs;
				RawSolveSampleCount += 1;
				if (BestRawSolveTimeMs == 0 || AttemptEntry.TimingBreakdown.RawSolveTimeMs < BestRawSolveTimeMs)
				{
					BestRawSolveTimeMs = AttemptEntry.TimingBreakdown.RawSolveTimeMs;
				}
			}

			if (AttemptEntry.TimingBreakdown.InspectionElapsedMs > 0)
			{
				InspectionTimeAccumulator += AttemptEntry.TimingBreakdown.InspectionElapsedMs;
				InspectionSampleCount += 1;
			}

			if (LastAttemptAtUtc.IsEmpty() || CompareUtcStrings(AttemptEntry.RecordedAtUtc, LastAttemptAtUtc) > 0)
			{
				LastAttemptAtUtc = AttemptEntry.RecordedAtUtc;
			}

			if (AttemptEntry.Result == EHyperTwistTrainingAttemptResult::Success
				&& (LastSuccessAtUtc.IsEmpty() || CompareUtcStrings(AttemptEntry.RecordedAtUtc, LastSuccessAtUtc) > 0))
			{
				LastSuccessAtUtc = AttemptEntry.RecordedAtUtc;
			}
		}

		EHyperTwistTrainingDeliveryMode ResolvePrimaryDeliveryMode() const
		{
			int32 BestModeIndex = 0;
			int32 BestModeCount = -1;
			for (int32 ModeIndex = 0; ModeIndex < UE_ARRAY_COUNT(DeliveryModeCounts); ++ModeIndex)
			{
				if (DeliveryModeCounts[ModeIndex] > BestModeCount)
				{
					BestModeCount = DeliveryModeCounts[ModeIndex];
					BestModeIndex = ModeIndex;
				}
			}

			return static_cast<EHyperTwistTrainingDeliveryMode>(BestModeIndex);
		}
	};

	struct FTimedSolveSample
	{
		FString AttemptId;
		FString SessionId;
		FString RecordedAtUtc;
		int32 TotalTimeMs = 0;
		int32 RawSolveTimeMs = 0;
	};

	bool IsTimedSolveEntry(const FHyperTwistTrainingSolveHistoryEntry& SolveEntry)
	{
		return SolveEntry.IsStructurallyValid()
			&& !SolveEntry.TimingBreakdown.bDidNotFinish
			&& SolveEntry.TotalTimeMs > 0
			&& SolveEntry.TimingBreakdown.RawSolveTimeMs > 0;
	}

	TArray<FTimedSolveSample> BuildTimedSolveSamples(const TArray<FHyperTwistTrainingRunRecord>& RunRecords)
	{
		TArray<FTimedSolveSample> TimedSolveSamples;
		for (const FHyperTwistTrainingRunRecord& RunRecord : RunRecords)
		{
			if (!RunRecord.IsStructurallyValid())
			{
				continue;
			}

			for (const FHyperTwistTrainingSolveHistoryEntry& SolveEntry : RunRecord.SolveHistory)
			{
				if (!IsTimedSolveEntry(SolveEntry))
				{
					continue;
				}

				FTimedSolveSample TimedSolveSample;
				TimedSolveSample.AttemptId = SolveEntry.AttemptId;
				TimedSolveSample.SessionId = RunRecord.Session.TrainingSessionId;
				TimedSolveSample.RecordedAtUtc = SolveEntry.RecordedAtUtc;
				TimedSolveSample.TotalTimeMs = SolveEntry.TotalTimeMs;
				TimedSolveSample.RawSolveTimeMs = SolveEntry.TimingBreakdown.RawSolveTimeMs;
				TimedSolveSamples.Add(TimedSolveSample);
			}
		}

		TimedSolveSamples.Sort([](const FTimedSolveSample& Left, const FTimedSolveSample& Right)
		{
			const int32 UtcCompare = CompareUtcStrings(Left.RecordedAtUtc, Right.RecordedAtUtc);
			if (UtcCompare != 0)
			{
				return UtcCompare < 0;
			}

			const int32 SessionCompare = Left.SessionId.Compare(Right.SessionId, ESearchCase::CaseSensitive);
			if (SessionCompare != 0)
			{
				return SessionCompare < 0;
			}

			return Left.AttemptId < Right.AttemptId;
		});

		return TimedSolveSamples;
	}

	int32 ComputeAverageMetricForSamples(
		const TArray<FTimedSolveSample>& TimedSolveSamples,
		const int32 StartIndex,
		const int32 WindowSize,
		const bool bUseRawSolveTime,
		const bool bTrimExtremes = false
	)
	{
		if (WindowSize <= 0 || StartIndex < 0 || StartIndex + WindowSize > TimedSolveSamples.Num())
		{
			return 0;
		}

		TArray<int32> MetricValues;
		MetricValues.Reserve(WindowSize);
		for (int32 Index = StartIndex; Index < StartIndex + WindowSize; ++Index)
		{
			MetricValues.Add(bUseRawSolveTime
				? TimedSolveSamples[Index].RawSolveTimeMs
				: TimedSolveSamples[Index].TotalTimeMs);
		}

		if (MetricValues.Num() == 0)
		{
			return 0;
		}

		int32 StartMetricIndex = 0;
		int32 EndMetricIndex = MetricValues.Num();
		if (bTrimExtremes && MetricValues.Num() >= 5)
		{
			MetricValues.Sort();
			StartMetricIndex = 1;
			EndMetricIndex = MetricValues.Num() - 1;
		}

		int64 MetricAccumulator = 0;
		for (int32 MetricIndex = StartMetricIndex; MetricIndex < EndMetricIndex; ++MetricIndex)
		{
			MetricAccumulator += MetricValues[MetricIndex];
		}

		const int32 Divisor = EndMetricIndex - StartMetricIndex;
		return Divisor > 0 ? static_cast<int32>(MetricAccumulator / Divisor) : 0;
	}

	bool ShouldTrimRollingWindowExtremes(const int32 WindowSize)
	{
		return WindowSize >= 5;
	}

	FString BuildRollingWindowLabel(const int32 WindowSize)
	{
		return WindowSize == 3
			? TEXT("mo3")
			: FString::Printf(TEXT("ao%d"), WindowSize);
	}

	FHyperTwistTrainingRollingWindowStat BuildRollingWindowStat(
		const TArray<FTimedSolveSample>& TimedSolveSamples,
		const int32 WindowSize
	)
	{
		FHyperTwistTrainingRollingWindowStat RollingWindowStat;
		RollingWindowStat.WindowSize = WindowSize;
		RollingWindowStat.WindowLabel = BuildRollingWindowLabel(WindowSize);
		RollingWindowStat.bTrimExtremes = ShouldTrimRollingWindowExtremes(WindowSize);
		if (WindowSize <= 0 || TimedSolveSamples.Num() == 0)
		{
			return RollingWindowStat;
		}

		const int32 EffectiveWindowSize = FMath::Min(WindowSize, TimedSolveSamples.Num());
		RollingWindowStat.SolveSampleCount = EffectiveWindowSize;
		RollingWindowStat.bWindowFilled = TimedSolveSamples.Num() >= WindowSize;
		RollingWindowStat.CurrentAverageTotalTimeMs = ComputeAverageMetricForSamples(
			TimedSolveSamples,
			TimedSolveSamples.Num() - EffectiveWindowSize,
			EffectiveWindowSize,
			false,
			RollingWindowStat.bTrimExtremes
		);
		RollingWindowStat.CurrentAverageRawSolveTimeMs = ComputeAverageMetricForSamples(
			TimedSolveSamples,
			TimedSolveSamples.Num() - EffectiveWindowSize,
			EffectiveWindowSize,
			true,
			RollingWindowStat.bTrimExtremes
		);

		if (!RollingWindowStat.bWindowFilled)
		{
			RollingWindowStat.BestAverageTotalTimeMs = RollingWindowStat.CurrentAverageTotalTimeMs;
			RollingWindowStat.BestAverageRawSolveTimeMs = RollingWindowStat.CurrentAverageRawSolveTimeMs;
			return RollingWindowStat;
		}

		for (int32 StartIndex = 0; StartIndex <= TimedSolveSamples.Num() - WindowSize; ++StartIndex)
		{
			const int32 AverageTotalTimeMs = ComputeAverageMetricForSamples(
				TimedSolveSamples,
				StartIndex,
				WindowSize,
				false,
				RollingWindowStat.bTrimExtremes
			);
			const int32 AverageRawSolveTimeMs = ComputeAverageMetricForSamples(
				TimedSolveSamples,
				StartIndex,
				WindowSize,
				true,
				RollingWindowStat.bTrimExtremes
			);

			if (AverageTotalTimeMs > 0
				&& (RollingWindowStat.BestAverageTotalTimeMs == 0
					|| AverageTotalTimeMs < RollingWindowStat.BestAverageTotalTimeMs))
			{
				RollingWindowStat.BestAverageTotalTimeMs = AverageTotalTimeMs;
			}

			if (AverageRawSolveTimeMs > 0
				&& (RollingWindowStat.BestAverageRawSolveTimeMs == 0
					|| AverageRawSolveTimeMs < RollingWindowStat.BestAverageRawSolveTimeMs))
			{
				RollingWindowStat.BestAverageRawSolveTimeMs = AverageRawSolveTimeMs;
			}
		}

		return RollingWindowStat;
	}

	TArray<FHyperTwistTrainingRunRecord> SortRunRecordsByUpdateUtc(const TArray<FHyperTwistTrainingRunRecord>& RunRecords)
	{
		TArray<FHyperTwistTrainingRunRecord> SortedRunRecords = RunRecords;
		SortedRunRecords.Sort([](const FHyperTwistTrainingRunRecord& Left, const FHyperTwistTrainingRunRecord& Right)
		{
			const FString LeftSortUtc = !Left.LastUpdatedAtUtc.IsEmpty()
				? Left.LastUpdatedAtUtc
				: (!Left.Session.EndedAtUtc.IsEmpty() ? Left.Session.EndedAtUtc : Left.Session.StartedAtUtc);
			const FString RightSortUtc = !Right.LastUpdatedAtUtc.IsEmpty()
				? Right.LastUpdatedAtUtc
				: (!Right.Session.EndedAtUtc.IsEmpty() ? Right.Session.EndedAtUtc : Right.Session.StartedAtUtc);
			const int32 UtcCompare = CompareUtcStrings(LeftSortUtc, RightSortUtc);
			if (UtcCompare != 0)
			{
				return UtcCompare < 0;
			}

			return Left.Session.TrainingSessionId < Right.Session.TrainingSessionId;
		});
		return SortedRunRecords;
	}

	FHyperTwistTrainingAttempt MakeAttemptFromTimerExportEntry(
		const FHyperTwistTrainingTimerExportEntry& TimerExportEntry
	)
	{
		FHyperTwistTrainingAttempt Attempt;
		Attempt.AttemptId = TimerExportEntry.AttemptId;
		Attempt.TrainingSessionId = TimerExportEntry.TrainingSessionId;
		Attempt.CaseId = TimerExportEntry.CaseId;
		Attempt.Result = TimerExportEntry.Result;
		Attempt.TotalTimeMs = TimerExportEntry.TotalTimeMs;
		Attempt.ExecutionTimeMs = TimerExportEntry.ExecutionTimeMs > 0
			? TimerExportEntry.ExecutionTimeMs
			: TimerExportEntry.TotalTimeMs;
		Attempt.RecognitionTimeMs = TimerExportEntry.RecognitionTimeMs;
		Attempt.TimingBreakdown = TimerExportEntry.TimingBreakdown;
		Attempt.Mistakes = 0;
		Attempt.ReplayId = TimerExportEntry.ReplayId;
		Attempt.CompletedAtUtc = TimerExportEntry.RecordedAtUtc;
		return Attempt;
	}

	FHyperTwistTrainingRunRecord BuildRunRecordFromTimerExportEntries(
		const FString& UserId,
		const FString& DeckId,
		const FString& TrainingSessionId,
		const TArray<FHyperTwistTrainingTimerExportEntry>& TimerExportEntries
	)
	{
		FHyperTwistTrainingRunRecord RunRecord;
		if (UserId.IsEmpty() || DeckId.IsEmpty() || TrainingSessionId.IsEmpty() || TimerExportEntries.Num() == 0)
		{
			return RunRecord;
		}

		TArray<FHyperTwistTrainingTimerExportEntry> SortedEntries = TimerExportEntries;
		SortedEntries.Sort([](const FHyperTwistTrainingTimerExportEntry& Left, const FHyperTwistTrainingTimerExportEntry& Right)
		{
			const int32 UtcCompare = CompareUtcStrings(Left.RecordedAtUtc, Right.RecordedAtUtc);
			if (UtcCompare != 0)
			{
				return UtcCompare < 0;
			}

			return Left.AttemptId < Right.AttemptId;
		});

		FHyperTwistTrainingSession Session;
		Session.TrainingSessionId = TrainingSessionId;
		Session.DeckId = DeckId;
		Session.UserId = UserId;
		Session.StartedAtUtc = SortedEntries[0].RecordedAtUtc;
		Session.EndedAtUtc = SortedEntries.Last().RecordedAtUtc;
		Session.Mode = EHyperTwistTrainingDeliveryMode::Timer;
		Session.SelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		Session.SessionState = EHyperTwistTrainingSessionState::Completed;
		Session.CurrentCaseId = SortedEntries.Last().CaseId;
		Session.AttemptCount = SortedEntries.Num();

		TArray<FHyperTwistTrainingAttempt> Attempts;
		Attempts.Reserve(SortedEntries.Num());
		for (const FHyperTwistTrainingTimerExportEntry& TimerExportEntry : SortedEntries)
		{
			Attempts.Add(MakeAttemptFromTimerExportEntry(TimerExportEntry));
			if (!TimerExportEntry.ReplayId.IsEmpty())
			{
				RunRecord.ReplayId = TimerExportEntry.ReplayId;
			}

			if (TimerExportEntry.Result != EHyperTwistTrainingAttemptResult::Aborted)
			{
				Session.SessionState = EHyperTwistTrainingSessionState::Completed;
			}
		}

		RunRecord.Session = Session;
        RunRecord.Summary = UHyperTwistTrainingLibrary::DeriveTrainingSessionSummary(
			Session,
			Attempts,
			FHyperTwistTrainingImportedRuntimeSelectionState()
		);
		RunRecord.Attempts = Attempts;
		RunRecord.LastUpdatedAtUtc = Session.EndedAtUtc;
		RunRecord.bCompleted = true;

		TMap<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>> ReviewHistoryByCase;
		for (const FHyperTwistTrainingAttempt& Attempt : Attempts)
		{
			if (!Attempt.IsStructurallyValid())
			{
				continue;
			}

			RunRecord.AttemptHistory.Add(UHyperTwistTrainingRepositoryLibrary::MakeAttemptHistoryEntry(Session, Attempt));
			if (Attempt.Result == EHyperTwistTrainingAttemptResult::Success
				|| Attempt.Result == EHyperTwistTrainingAttemptResult::Failure
				|| Attempt.Result == EHyperTwistTrainingAttemptResult::Timeout
				|| Attempt.Result == EHyperTwistTrainingAttemptResult::DNF)
			{
				RunRecord.SolveHistory.Add(UHyperTwistTrainingRepositoryLibrary::MakeSolveHistoryEntry(Attempt));
			}

			TArray<FHyperTwistTrainingReviewHistoryEntry>& ExistingReviewHistory = ReviewHistoryByCase.FindOrAdd(Attempt.CaseId);
			FHyperTwistTrainingReviewHistoryEntry ReviewHistoryEntry =
				UHyperTwistTrainingRepositoryLibrary::MakeReviewHistoryEntry(Session, Attempt, ExistingReviewHistory);
			if (ReviewHistoryEntry.IsStructurallyValid())
			{
				ExistingReviewHistory.Add(ReviewHistoryEntry);
				RunRecord.ReviewHistory.Add(ReviewHistoryEntry);
			}
		}

		return RunRecord;
	}

	TArray<FHyperTwistTrainingCaseLearnerState> BuildLearnerStates(
		const TArray<FHyperTwistTrainingRunRecord>& RunRecords
	)
	{
		TArray<FHyperTwistTrainingCaseLearnerState> LearnerStates;
		const TMap<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>> ReviewHistoryByCase = BuildReviewHistoryByCase(RunRecords);
		for (const TPair<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>>& Pair : ReviewHistoryByCase)
		{
			FString UserId;
			FString DeckId;
			FString CaseId;
			if (!SplitCaseKey(Pair.Key, UserId, DeckId, CaseId))
			{
				continue;
			}

			FHyperTwistTrainingCaseLearnerState LearnerState = DeriveLearnerStateFromReviewHistory(UserId, DeckId, CaseId, Pair.Value);
			if (LearnerState.IsStructurallyValid())
			{
				LearnerStates.Add(LearnerState);
			}
		}

		LearnerStates.Sort([](const FHyperTwistTrainingCaseLearnerState& Left, const FHyperTwistTrainingCaseLearnerState& Right)
		{
			if (Left.UserId != Right.UserId)
			{
				return Left.UserId < Right.UserId;
			}

			if (Left.DeckId != Right.DeckId)
			{
				return Left.DeckId < Right.DeckId;
			}

			return Left.CaseId < Right.CaseId;
		});
		return LearnerStates;
	}
}

FHyperTwistTrainingAttemptHistoryEntry UHyperTwistTrainingRepositoryLibrary::MakeAttemptHistoryEntry(
	const FHyperTwistTrainingSession& Session,
	const FHyperTwistTrainingAttempt& Attempt
)
{
	FHyperTwistTrainingAttemptHistoryEntry Entry;
	Entry.AttemptId = Attempt.AttemptId;
	Entry.TrainingSessionId = Session.TrainingSessionId;
	Entry.CaseId = Attempt.CaseId;
	Entry.RecordedAtUtc = Attempt.CompletedAtUtc;
	Entry.DeliveryMode = Session.Mode;
	Entry.Result = Attempt.Result;
	Entry.ExecutionTimeMs = Attempt.ExecutionTimeMs;
	Entry.RecognitionTimeMs = Attempt.RecognitionTimeMs;
	Entry.TotalTimeMs = Attempt.TotalTimeMs;
	Entry.TimingBreakdown = Attempt.TimingBreakdown;
	Entry.bHadMistake = Attempt.Mistakes > 0;
	Entry.bAborted = Attempt.Result == EHyperTwistTrainingAttemptResult::Aborted;
	Entry.bTimerOnly = Session.Mode == EHyperTwistTrainingDeliveryMode::Timer;
	Entry.ReplayId = Attempt.ReplayId;
	return Entry;
}

EHyperTwistTrainingReviewGrade UHyperTwistTrainingRepositoryLibrary::DeriveReviewGrade(
	const FHyperTwistTrainingAttemptHistoryEntry& AttemptHistoryEntry,
	const TArray<FHyperTwistTrainingReviewHistoryEntry>& ExistingReviewHistory
)
{
	if (AttemptHistoryEntry.bAborted
		|| AttemptHistoryEntry.Result == EHyperTwistTrainingAttemptResult::Aborted
		|| AttemptHistoryEntry.Result == EHyperTwistTrainingAttemptResult::DNF
		|| AttemptHistoryEntry.Result == EHyperTwistTrainingAttemptResult::Timeout
		|| AttemptHistoryEntry.Result == EHyperTwistTrainingAttemptResult::Failure)
	{
		return EHyperTwistTrainingReviewGrade::Again;
	}

	const double ExecutionBaseline = HyperTwistTrainingRepositoryLibraryInternal::GetMedianMetric(
		ExistingReviewHistory,
		&FHyperTwistTrainingReviewHistoryEntry::ExecutionTimeMs
	);
	const double RecognitionBaseline = HyperTwistTrainingRepositoryLibraryInternal::GetMedianMetric(
		ExistingReviewHistory,
		&FHyperTwistTrainingReviewHistoryEntry::RecognitionTimeMs
	);
	const bool bMuchSlowerExecution = HyperTwistTrainingRepositoryLibraryInternal::IsMuchSlower(
		AttemptHistoryEntry.ExecutionTimeMs,
		ExecutionBaseline
	);
	const bool bMuchSlowerRecognition = HyperTwistTrainingRepositoryLibraryInternal::IsMuchSlower(
		AttemptHistoryEntry.RecognitionTimeMs,
		RecognitionBaseline
	);

	if (AttemptHistoryEntry.bHadMistake || bMuchSlowerExecution || bMuchSlowerRecognition)
	{
		return EHyperTwistTrainingReviewGrade::Hard;
	}

	const int32 RecentWindowCount = FMath::Min(11, ExistingReviewHistory.Num());
	bool bCanBeEasy = RecentWindowCount == 11;
	for (int32 Index = ExistingReviewHistory.Num() - RecentWindowCount; Index < ExistingReviewHistory.Num(); ++Index)
	{
		if (Index < 0 || !HyperTwistTrainingRepositoryLibraryInternal::IsSuccessfulReview(ExistingReviewHistory[Index]))
		{
			bCanBeEasy = false;
			break;
		}
	}

	if (bCanBeEasy)
	{
		if (ExecutionBaseline > 0.0 && (AttemptHistoryEntry.ExecutionTimeMs <= 0 || AttemptHistoryEntry.ExecutionTimeMs > ExecutionBaseline))
		{
			bCanBeEasy = false;
		}
		if (RecognitionBaseline > 0.0 && (AttemptHistoryEntry.RecognitionTimeMs <= 0 || AttemptHistoryEntry.RecognitionTimeMs > RecognitionBaseline))
		{
			bCanBeEasy = false;
		}
	}

	return bCanBeEasy ? EHyperTwistTrainingReviewGrade::Easy : EHyperTwistTrainingReviewGrade::Good;
}

FHyperTwistTrainingReviewHistoryEntry UHyperTwistTrainingRepositoryLibrary::MakeReviewHistoryEntry(
	const FHyperTwistTrainingSession& Session,
	const FHyperTwistTrainingAttempt& Attempt,
	const TArray<FHyperTwistTrainingReviewHistoryEntry>& ExistingReviewHistory
)
{
	const FHyperTwistTrainingAttemptHistoryEntry AttemptHistoryEntry = MakeAttemptHistoryEntry(Session, Attempt);

	FHyperTwistTrainingReviewHistoryEntry ReviewEntry;
	ReviewEntry.AttemptId = AttemptHistoryEntry.AttemptId;
	ReviewEntry.TrainingSessionId = AttemptHistoryEntry.TrainingSessionId;
	ReviewEntry.CaseId = AttemptHistoryEntry.CaseId;
	ReviewEntry.ReviewedAtUtc = AttemptHistoryEntry.RecordedAtUtc;
	ReviewEntry.Grade = DeriveReviewGrade(AttemptHistoryEntry, ExistingReviewHistory);
	ReviewEntry.DeliveryMode = AttemptHistoryEntry.DeliveryMode;
	ReviewEntry.ExecutionTimeMs = AttemptHistoryEntry.ExecutionTimeMs;
	ReviewEntry.RecognitionTimeMs = AttemptHistoryEntry.RecognitionTimeMs;
	ReviewEntry.TotalTimeMs = AttemptHistoryEntry.TotalTimeMs;
	ReviewEntry.TimingBreakdown = AttemptHistoryEntry.TimingBreakdown;
	ReviewEntry.bHadMistake = AttemptHistoryEntry.bHadMistake;
	ReviewEntry.bAborted = AttemptHistoryEntry.bAborted;
	ReviewEntry.bTimerOnly = AttemptHistoryEntry.bTimerOnly;
	ReviewEntry.ReplayId = AttemptHistoryEntry.ReplayId;
	return ReviewEntry;
}

FHyperTwistTrainingSolveHistoryEntry UHyperTwistTrainingRepositoryLibrary::MakeSolveHistoryEntry(
	const FHyperTwistTrainingAttempt& Attempt
)
{
	FHyperTwistTrainingSolveHistoryEntry Entry;
	Entry.AttemptId = Attempt.AttemptId;
	Entry.CaseId = Attempt.CaseId;
	Entry.RecordedAtUtc = Attempt.CompletedAtUtc;
	Entry.ExecutionTimeMs = Attempt.ExecutionTimeMs;
	Entry.RecognitionTimeMs = Attempt.RecognitionTimeMs;
	Entry.TotalTimeMs = Attempt.TotalTimeMs;
	Entry.TimingBreakdown = Attempt.TimingBreakdown;
	return Entry;
}

FHyperTwistTrainingRunRecord UHyperTwistTrainingRepositoryLibrary::BuildRunRecord(
	const FHyperTwistTrainingRunState& RunState
)
{
	FHyperTwistTrainingRunRecord RunRecord;
	if (!RunState.IsStructurallyValid())
	{
		return RunRecord;
	}

	RunRecord.Session = RunState.Session;
	RunRecord.Summary = UHyperTwistTrainingLibrary::DeriveTrainingSessionSummary(
		RunState.Session,
       RunState.Attempts,
		RunState.ImportedRuntimeSelectionState
	);
	RunRecord.ImportedRuntimeSelectionState = RunState.ImportedRuntimeSelectionState;
	RunRecord.ImportedGeneratedModeLaunchRequest = RunState.ImportedGeneratedModeLaunchRequest;
	RunRecord.TemplateLaunchProvenance = RunState.TemplateLaunchProvenance;
	RunRecord.Attempts = RunState.Attempts;
	RunRecord.RemainingCaseIds = RunState.RemainingCaseIds;
	RunRecord.ReplayId = RunState.ReplayPacket.ReplayId;
	RunRecord.LastUpdatedAtUtc = !RunState.Session.EndedAtUtc.IsEmpty()
		? RunState.Session.EndedAtUtc
		: RunRecord.Summary.LastCompletedAtUtc;
	RunRecord.bCompleted = RunState.Session.SessionState == EHyperTwistTrainingSessionState::Completed
		|| RunState.Session.SessionState == EHyperTwistTrainingSessionState::Aborted;

	// Review grade derivation depends on the prior case-local review history inside this run.
	TMap<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>> ReviewHistoryByCase;
	for (const FHyperTwistTrainingAttempt& Attempt : RunState.Attempts)
	{
		if (!Attempt.IsStructurallyValid())
		{
			continue;
		}

		RunRecord.AttemptHistory.Add(MakeAttemptHistoryEntry(RunState.Session, Attempt));

		if (Attempt.Result == EHyperTwistTrainingAttemptResult::Success
			|| Attempt.Result == EHyperTwistTrainingAttemptResult::Failure
			|| Attempt.Result == EHyperTwistTrainingAttemptResult::Timeout
			|| Attempt.Result == EHyperTwistTrainingAttemptResult::DNF)
		{
			RunRecord.SolveHistory.Add(MakeSolveHistoryEntry(Attempt));
		}

		TArray<FHyperTwistTrainingReviewHistoryEntry>& ExistingReviewHistory = ReviewHistoryByCase.FindOrAdd(Attempt.CaseId);
		FHyperTwistTrainingReviewHistoryEntry ReviewEntry = MakeReviewHistoryEntry(
			RunState.Session,
			Attempt,
			ExistingReviewHistory
		);
		if (ReviewEntry.IsStructurallyValid())
		{
			ExistingReviewHistory.Add(ReviewEntry);
			RunRecord.ReviewHistory.Add(ReviewEntry);
		}
	}

	return RunRecord;
}

FHyperTwistTrainingMethodDrillFavoriteEntry UHyperTwistTrainingRepositoryLibrary::MakeMethodDrillFavoriteEntry(
	const FHyperTwistTrainingMethodDrillDefinition& DrillDefinition,
	const FString& UserId,
	const FString& CaseId,
	const FString& AddedAtUtc
)
{
	FHyperTwistTrainingMethodDrillFavoriteEntry FavoriteEntry;
	if (!DrillDefinition.IsStructurallyValid() || UserId.IsEmpty() || CaseId.IsEmpty())
	{
		return FavoriteEntry;
	}

	const FHyperTwistTrainingCase* MatchingCase = DrillDefinition.SourceDeck.Cases.FindByPredicate(
		[&CaseId](const FHyperTwistTrainingCase& TrainingCase)
		{
			return TrainingCase.CaseId == CaseId;
		}
	);
	if (MatchingCase == nullptr || !MatchingCase->IsStructurallyValid())
	{
		return FavoriteEntry;
	}

	FavoriteEntry.UserId = UserId;
	FavoriteEntry.DrillId = DrillDefinition.DrillId;
	FavoriteEntry.CaseId = CaseId;
	FavoriteEntry.SourceDeckId = DrillDefinition.SourceDeckId;
	FavoriteEntry.MethodDescriptor = DrillDefinition.MethodDescriptor;
	FavoriteEntry.AddedAtUtc = AddedAtUtc.IsEmpty() ? FDateTime::UtcNow().ToIso8601() : AddedAtUtc;
	FavoriteEntry.Tags = DrillDefinition.Tags;
	for (const FString& Tag : MatchingCase->Tags)
	{
		FavoriteEntry.Tags.AddUnique(Tag);
	}
	FavoriteEntry.Tags.AddUnique(TEXT("favorite"));
	return FavoriteEntry;
}

TArray<FHyperTwistTrainingMethodDrillFavoriteEntry> UHyperTwistTrainingRepositoryLibrary::ListMethodDrillFavorites(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& MethodSegmentId
)
{
	TArray<FHyperTwistTrainingMethodDrillFavoriteEntry> Favorites;
	for (const FHyperTwistTrainingMethodDrillFavoriteEntry& FavoriteEntry : RepositoryState.StoredMethodDrillFavorites)
	{
		if (!FavoriteEntry.IsStructurallyValid())
		{
			continue;
		}

		const bool bMatchesUser = UserId.IsEmpty() || FavoriteEntry.UserId == UserId;
		const bool bMatchesSegment = MethodSegmentId.IsEmpty()
			|| FavoriteEntry.MethodDescriptor.SegmentId == MethodSegmentId;
		if (bMatchesUser && bMatchesSegment)
		{
			Favorites.Add(FavoriteEntry);
		}
	}

	Favorites.Sort([](
		const FHyperTwistTrainingMethodDrillFavoriteEntry& Left,
		const FHyperTwistTrainingMethodDrillFavoriteEntry& Right
	)
	{
		const int32 AddedAtCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.AddedAtUtc,
			Right.AddedAtUtc
		);
		if (AddedAtCompare != 0)
		{
			return AddedAtCompare > 0;
		}
		if (Left.DrillId != Right.DrillId)
		{
			return Left.DrillId < Right.DrillId;
		}
		return Left.CaseId < Right.CaseId;
	});

	return Favorites;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertMethodDrillFavorite(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingMethodDrillFavoriteEntry& FavoriteEntry
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	if (!FavoriteEntry.IsStructurallyValid())
	{
		return UpdatedRepositoryState;
	}

	const FHyperTwistTrainingMethodDrillFavoriteEntry NormalizedFavorite =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeMethodDrillFavoriteEntry(FavoriteEntry);
	FHyperTwistTrainingMethodDrillFavoriteEntry* ExistingFavorite =
		UpdatedRepositoryState.StoredMethodDrillFavorites.FindByPredicate(
			[&NormalizedFavorite](const FHyperTwistTrainingMethodDrillFavoriteEntry& Candidate)
			{
				return Candidate.UserId == NormalizedFavorite.UserId
					&& Candidate.DrillId == NormalizedFavorite.DrillId
					&& Candidate.CaseId == NormalizedFavorite.CaseId;
			}
		);

	if (ExistingFavorite != nullptr)
	{
		*ExistingFavorite = NormalizedFavorite;
	}
	else
	{
		UpdatedRepositoryState.StoredMethodDrillFavorites.Add(NormalizedFavorite);
	}

	return UpdatedRepositoryState;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::RemoveMethodDrillFavorite(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DrillId,
	const FString& CaseId
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	if (UserId.IsEmpty() || DrillId.IsEmpty() || CaseId.IsEmpty())
	{
		return UpdatedRepositoryState;
	}

	UpdatedRepositoryState.StoredMethodDrillFavorites.RemoveAll(
		[&UserId, &DrillId, &CaseId](const FHyperTwistTrainingMethodDrillFavoriteEntry& Candidate)
		{
			return Candidate.UserId == UserId
				&& Candidate.DrillId == DrillId
				&& Candidate.CaseId == CaseId;
		}
	);
	return UpdatedRepositoryState;
}

TArray<FHyperTwistTrainingMethodDrillBatch> UHyperTwistTrainingRepositoryLibrary::ListMethodDrillBatches(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& MethodSegmentId
)
{
	TArray<FHyperTwistTrainingMethodDrillBatch> Batches;
	for (const FHyperTwistTrainingMethodDrillBatch& DrillBatch : RepositoryState.StoredMethodDrillBatches)
	{
		if (!DrillBatch.IsStructurallyValid())
		{
			continue;
		}

		const bool bMatchesUser = UserId.IsEmpty() || DrillBatch.UserId == UserId;
		const bool bMatchesSegment = MethodSegmentId.IsEmpty()
			|| DrillBatch.MethodDescriptor.SegmentId == MethodSegmentId;
		if (bMatchesUser && bMatchesSegment)
		{
			Batches.Add(DrillBatch);
		}
	}

	Batches.Sort([](const FHyperTwistTrainingMethodDrillBatch& Left, const FHyperTwistTrainingMethodDrillBatch& Right)
	{
		const int32 UpdatedAtCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastUpdatedAtUtc,
			Right.LastUpdatedAtUtc
		);
		if (UpdatedAtCompare != 0)
		{
			return UpdatedAtCompare > 0;
		}
		return Left.BatchId < Right.BatchId;
	});

	return Batches;
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetMethodDrillBatch(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& BatchId,
	FHyperTwistTrainingMethodDrillBatch& OutBatch
)
{
	OutBatch = FHyperTwistTrainingMethodDrillBatch();
	if (UserId.IsEmpty() || BatchId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingMethodDrillBatch* MatchingBatch =
		RepositoryState.StoredMethodDrillBatches.FindByPredicate(
			[&UserId, &BatchId](const FHyperTwistTrainingMethodDrillBatch& Candidate)
			{
				return Candidate.UserId == UserId && Candidate.BatchId == BatchId;
			}
		);
	if (MatchingBatch == nullptr)
	{
		return false;
	}

	OutBatch = *MatchingBatch;
	return OutBatch.IsStructurallyValid();
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertMethodDrillBatch(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingMethodDrillBatch& DrillBatch
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	if (!DrillBatch.IsStructurallyValid())
	{
		return UpdatedRepositoryState;
	}

	const FHyperTwistTrainingMethodDrillBatch NormalizedBatch =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeMethodDrillBatch(DrillBatch);
	FHyperTwistTrainingMethodDrillBatch* ExistingBatch =
		UpdatedRepositoryState.StoredMethodDrillBatches.FindByPredicate(
			[&NormalizedBatch](const FHyperTwistTrainingMethodDrillBatch& Candidate)
			{
				return Candidate.UserId == NormalizedBatch.UserId
					&& Candidate.BatchId == NormalizedBatch.BatchId;
			}
		);

	if (ExistingBatch != nullptr)
	{
		*ExistingBatch = NormalizedBatch;
	}
	else
	{
		UpdatedRepositoryState.StoredMethodDrillBatches.Add(NormalizedBatch);
	}

	return UpdatedRepositoryState;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::RemoveMethodDrillBatch(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& BatchId
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	if (UserId.IsEmpty() || BatchId.IsEmpty())
	{
		return UpdatedRepositoryState;
	}

	UpdatedRepositoryState.StoredMethodDrillBatches.RemoveAll(
		[&UserId, &BatchId](const FHyperTwistTrainingMethodDrillBatch& Candidate)
		{
			return Candidate.UserId == UserId && Candidate.BatchId == BatchId;
		}
	);
	return UpdatedRepositoryState;
}

FHyperTwistTrainingMethodDrillBatchReadiness UHyperTwistTrainingRepositoryLibrary::DeriveDrillBatchReadiness(
	const FHyperTwistTrainingMethodDrillBatch& DrillBatch,
	const FHyperTwistTrainingMethodDrillDefinition& CurrentDefinition
)
{
	FHyperTwistTrainingMethodDrillBatchReadiness Readiness;
	Readiness.BatchId = DrillBatch.BatchId;
	Readiness.LastUpdatedAtUtc = DrillBatch.LastUpdatedAtUtc;

	if (!DrillBatch.IsStructurallyValid())
	{
		return Readiness;
	}

	TSet<FString> AllowedCaseIds;
	for (const FHyperTwistTrainingCase& TrainingCase : CurrentDefinition.SourceDeck.Cases)
	{
		if (!TrainingCase.CaseId.IsEmpty())
		{
			AllowedCaseIds.Add(TrainingCase.CaseId);
		}
	}
	if (CurrentDefinition.FocusCaseIds.Num() > 0)
	{
		for (const FString& FocusId : CurrentDefinition.FocusCaseIds)
		{
			AllowedCaseIds.Add(FocusId);
		}
	}

	bool bFoundStaleCase = false;

	for (const FString& PendingId : DrillBatch.PendingCaseIds)
	{
		if (!AllowedCaseIds.Contains(PendingId))
		{
			bFoundStaleCase = true;
		}
	}
	if (!DrillBatch.CurrentCaseId.IsEmpty() && !AllowedCaseIds.Contains(DrillBatch.CurrentCaseId))
	{
		bFoundStaleCase = true;
	}
	for (const FString& CompletedId : DrillBatch.CompletedCaseIds)
	{
		if (!AllowedCaseIds.Contains(CompletedId))
		{
			bFoundStaleCase = true;
		}
	}

	Readiness.bIsStale = bFoundStaleCase;

	const int32 PendingCount = DrillBatch.PendingCaseIds.Num();
	const bool bHasActiveCurrent = !DrillBatch.CurrentCaseId.IsEmpty()
		&& !DrillBatch.CompletedCaseIds.Contains(DrillBatch.CurrentCaseId);
	Readiness.RemainingCaseCount = PendingCount + (bHasActiveCurrent ? 1 : 0);
	Readiness.CompletedCaseCount = DrillBatch.CompletedCaseIds.Num();
	Readiness.bIsResumable = Readiness.RemainingCaseCount > 0;

	const int32 Total = Readiness.RemainingCaseCount + Readiness.CompletedCaseCount;
	Readiness.CompletionFraction = Total > 0
		? static_cast<float>(Readiness.CompletedCaseCount) / static_cast<float>(Total)
		: 0.0f;

	return Readiness;
}

TArray<FHyperTwistTrainingMethodDrillBatch> UHyperTwistTrainingRepositoryLibrary::ListResumableDrillBatches(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& MethodSegmentId
)
{
	TArray<FHyperTwistTrainingMethodDrillBatch> AllBatches =
		ListMethodDrillBatches(RepositoryState, UserId, MethodSegmentId);

	TArray<FHyperTwistTrainingMethodDrillBatch> Resumable;
	for (const FHyperTwistTrainingMethodDrillBatch& Batch : AllBatches)
	{
		const bool bHasPending = Batch.PendingCaseIds.Num() > 0;
		const bool bHasActiveCurrent = !Batch.CurrentCaseId.IsEmpty()
			&& !Batch.CompletedCaseIds.Contains(Batch.CurrentCaseId);
		if (bHasPending || bHasActiveCurrent)
		{
			Resumable.Add(Batch);
		}
	}
	return Resumable;
}

FHyperTwistTrainingMethodDrillBatch UHyperTwistTrainingRepositoryLibrary::RebuildDrillBatchForResume(
	const FHyperTwistTrainingMethodDrillBatch& SavedBatch,
	const FHyperTwistTrainingMethodDrillDefinition& CurrentDefinition
)
{
	FHyperTwistTrainingMethodDrillBatch Rebuilt = SavedBatch;

	if (!SavedBatch.IsStructurallyValid())
	{
		return Rebuilt;
	}

	TSet<FString> AllowedCaseIds;
	for (const FHyperTwistTrainingCase& TrainingCase : CurrentDefinition.SourceDeck.Cases)
	{
		if (!TrainingCase.CaseId.IsEmpty())
		{
			AllowedCaseIds.Add(TrainingCase.CaseId);
		}
	}
	if (CurrentDefinition.FocusCaseIds.Num() > 0)
	{
		for (const FString& FocusId : CurrentDefinition.FocusCaseIds)
		{
			AllowedCaseIds.Add(FocusId);
		}
	}

	Rebuilt.PendingCaseIds.RemoveAll([&AllowedCaseIds](const FString& CaseId)
	{
		return !AllowedCaseIds.Contains(CaseId);
	});

	Rebuilt.CompletedCaseIds.RemoveAll([&AllowedCaseIds](const FString& CaseId)
	{
		return !AllowedCaseIds.Contains(CaseId);
	});

	Rebuilt.Responses.RemoveAll([&AllowedCaseIds](const FHyperTwistTrainingMethodDrillResponseRecord& Record)
	{
		return !AllowedCaseIds.Contains(Record.CaseId);
	});

	const bool bCurrentStillValid = !Rebuilt.CurrentCaseId.IsEmpty()
		&& AllowedCaseIds.Contains(Rebuilt.CurrentCaseId);
	if (!bCurrentStillValid)
	{
		if (Rebuilt.PendingCaseIds.Num() > 0)
		{
			Rebuilt.CurrentCaseId = Rebuilt.PendingCaseIds[0];
			Rebuilt.PendingCaseIds.RemoveAt(0);
		}
		else
		{
			Rebuilt.CurrentCaseId = FString();
		}
	}

	Rebuilt.LastUpdatedAtUtc = FDateTime::UtcNow().ToIso8601();
	return Rebuilt;
}

FHyperTwistTrainingMethodDrillDefinition UHyperTwistTrainingRepositoryLibrary::BuildDrillDefinitionFavoriteFirst(
	const FHyperTwistTrainingMethodDrillDefinition& BaseDefinition,
	const TArray<FHyperTwistTrainingMethodDrillFavoriteEntry>& Favorites,
	int32 MaxFavoriteCases
)
{
	FHyperTwistTrainingMethodDrillDefinition Result = BaseDefinition;

	if (!BaseDefinition.IsStructurallyValid())
	{
		return Result;
	}

	TSet<FString> DeckCaseIds;
	for (const FHyperTwistTrainingCase& TrainingCase : BaseDefinition.SourceDeck.Cases)
	{
		if (!TrainingCase.CaseId.IsEmpty())
		{
			DeckCaseIds.Add(TrainingCase.CaseId);
		}
	}

	TArray<FString> FavoriteCaseIds;
	for (const FHyperTwistTrainingMethodDrillFavoriteEntry& FavoriteEntry : Favorites)
	{
		if (!FavoriteEntry.CaseId.IsEmpty() && DeckCaseIds.Contains(FavoriteEntry.CaseId))
		{
			FavoriteCaseIds.AddUnique(FavoriteEntry.CaseId);
			if (MaxFavoriteCases > 0 && FavoriteCaseIds.Num() >= MaxFavoriteCases)
			{
				break;
			}
		}
	}

	TArray<FString> OrderedCaseIds = FavoriteCaseIds;
	for (const FHyperTwistTrainingCase& TrainingCase : BaseDefinition.SourceDeck.Cases)
	{
		if (!TrainingCase.CaseId.IsEmpty() && !OrderedCaseIds.Contains(TrainingCase.CaseId))
		{
			OrderedCaseIds.Add(TrainingCase.CaseId);
		}
	}

	Result.FocusCaseIds = OrderedCaseIds;
	if (FavoriteCaseIds.Num() > 0)
	{
		Result.EntrySource = EHyperTwistTrainingDrillEntrySource::Favorites;
	}
	return Result;
}

FHyperTwistTrainingSessionTemplate UHyperTwistTrainingRepositoryLibrary::BuildMethodDrillFollowUpTemplate(
	const FHyperTwistTrainingMethodDrillDiagnosticPacket& DiagnosticPacket,
	const FString& TemplateId
)
{
	FHyperTwistTrainingSessionTemplate SessionTemplate;
	if (!DiagnosticPacket.IsStructurallyValid()
		|| !DiagnosticPacket.bNeedsFollowUpTemplate
		|| DiagnosticPacket.SourceDeckId.IsEmpty())
	{
		return SessionTemplate;
	}

	SessionTemplate.UserId = DiagnosticPacket.UserId;
	SessionTemplate.TemplateId = TemplateId.IsEmpty()
		? FString::Printf(TEXT("method_drill_follow_up_%s"), *DiagnosticPacket.RunId)
		: TemplateId;
	SessionTemplate.Title = !DiagnosticPacket.StageLabel.IsEmpty()
		? FString::Printf(TEXT("%s Drill Follow-Up"), *DiagnosticPacket.StageLabel)
		: TEXT("Method Drill Follow-Up");
	SessionTemplate.TemplateKind =
		DiagnosticPacket.bBoundaryTriggeredByPendingCases || DiagnosticPacket.bBoundaryTriggeredByRepeatBurden
			? EHyperTwistTrainingSessionTemplateKind::Recovery
			: EHyperTwistTrainingSessionTemplateKind::ReviewPlan;
	SessionTemplate.FocusDeckId = DiagnosticPacket.SourceDeckId;
	SessionTemplate.MethodSegmentId = DiagnosticPacket.MethodSegmentId;

	switch (DiagnosticPacket.DrillMode)
	{
	case EHyperTwistTrainingDrillModeKind::Recognition:
	case EHyperTwistTrainingDrillModeKind::Reconstruction:
		SessionTemplate.SuggestedMode = EHyperTwistTrainingDeliveryMode::RecognitionAssisted;
		break;
	case EHyperTwistTrainingDrillModeKind::Execution:
		SessionTemplate.SuggestedMode = EHyperTwistTrainingDeliveryMode::VirtualCube;
		break;
	case EHyperTwistTrainingDrillModeKind::Recall:
	default:
		SessionTemplate.SuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		break;
	}

	SessionTemplate.SuggestedSelectionPolicy =
		DiagnosticPacket.bBoundaryTriggeredByPendingCases
			? EHyperTwistTrainingSelectionPolicy::Scripted
			: EHyperTwistTrainingSelectionPolicy::Weighted;
	SessionTemplate.FocusCaseIds =
		HyperTwistTrainingRepositoryLibraryInternal::DeduplicateTemplateCaseIds(DiagnosticPacket.FocusCaseIds);
	if (SessionTemplate.FocusCaseIds.Num() == 0)
	{
		return FHyperTwistTrainingSessionTemplate();
	}

	SessionTemplate.RecommendedCaseCount = FMath::Max(
		1,
		FMath::Min(
			SessionTemplate.FocusCaseIds.Num(),
			DiagnosticPacket.RecommendedReviewGrade == EHyperTwistTrainingReviewGrade::Again ? 6 : 4
		)
	);
	SessionTemplate.GuidanceLabel = !DiagnosticPacket.BoundaryReason.IsEmpty()
		? DiagnosticPacket.BoundaryReason
		: TEXT("method-drill follow-up");
	SessionTemplate.bPreferReviewRun =
		DiagnosticPacket.bNeedsReviewPlanBridge
		|| DiagnosticPacket.RecommendedReviewGrade != EHyperTwistTrainingReviewGrade::Easy;
	SessionTemplate.bCoachReview = false;
	SessionTemplate.bPreferShortReviewSet = SessionTemplate.RecommendedCaseCount <= 4;
	SessionTemplate.bUserEditable = false;
	SessionTemplate.bUserCustomized = false;
	SessionTemplate.bUserCreated = false;
	SessionTemplate.LastUpdatedAtUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(DiagnosticPacket.ReferenceUtc);
	return SessionTemplate.IsStructurallyValid() ? SessionTemplate : FHyperTwistTrainingSessionTemplate();
}

TArray<FHyperTwistTrainingFriendLinkRecord> UHyperTwistTrainingRepositoryLibrary::ListFriendLinksForUser(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId
)
{
	if (UserId.IsEmpty())
	{
		return TArray<FHyperTwistTrainingFriendLinkRecord>();
	}

	TArray<FHyperTwistTrainingFriendLinkRecord> FriendLinks;
	for (const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord : RepositoryState.StoredFriendLinks)
	{
		const FHyperTwistTrainingFriendLinkRecord NormalizedFriendLinkRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(FriendLinkRecord);
		if (NormalizedFriendLinkRecord.IsStructurallyValid() && NormalizedFriendLinkRecord.UserId == UserId)
		{
			FriendLinks.Add(NormalizedFriendLinkRecord);
		}
	}

	return HyperTwistTrainingRepositoryLibraryInternal::SortFriendLinksByUpdateUtc(FriendLinks);
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetFriendLinkRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& FriendUserId,
	FHyperTwistTrainingFriendLinkRecord& OutFriendLinkRecord
)
{
	OutFriendLinkRecord = FHyperTwistTrainingFriendLinkRecord();
	if (UserId.IsEmpty() || FriendUserId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingFriendLinkRecord* ExistingRecord =
		RepositoryState.StoredFriendLinks.FindByPredicate(
			[&UserId, &FriendUserId](const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord)
			{
				const FHyperTwistTrainingFriendLinkRecord NormalizedFriendLinkRecord =
					HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(FriendLinkRecord);
				return NormalizedFriendLinkRecord.UserId == UserId
					&& NormalizedFriendLinkRecord.FriendSnapshot.FriendUserId == FriendUserId;
			}
		);
	if (ExistingRecord == nullptr)
	{
		return false;
	}

	OutFriendLinkRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(*ExistingRecord);
	return OutFriendLinkRecord.IsStructurallyValid();
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertFriendLinkRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord
)
{
	FHyperTwistTrainingRepositoryState UpdatedState = RepositoryState;
	const FHyperTwistTrainingFriendLinkRecord NormalizedFriendLinkRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(FriendLinkRecord);
	if (!NormalizedFriendLinkRecord.IsStructurallyValid())
	{
		return UpdatedState;
	}

	const FString FriendLinkKey = HyperTwistTrainingRepositoryLibraryInternal::MakeFriendLinkKey(
		NormalizedFriendLinkRecord.UserId,
		NormalizedFriendLinkRecord.FriendSnapshot.FriendUserId
	);
	const int32 ExistingIndex = UpdatedState.StoredFriendLinks.IndexOfByPredicate(
		[&FriendLinkKey](const FHyperTwistTrainingFriendLinkRecord& ExistingRecord)
		{
			const FHyperTwistTrainingFriendLinkRecord NormalizedExistingRecord =
				HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(ExistingRecord);
			return HyperTwistTrainingRepositoryLibraryInternal::MakeFriendLinkKey(
				NormalizedExistingRecord.UserId,
				NormalizedExistingRecord.FriendSnapshot.FriendUserId
			) == FriendLinkKey;
		}
	);
	if (ExistingIndex >= 0)
	{
		UpdatedState.StoredFriendLinks[ExistingIndex] = NormalizedFriendLinkRecord;
	}
	else
	{
		UpdatedState.StoredFriendLinks.Add(NormalizedFriendLinkRecord);
	}

	return RepairRepositoryState(UpdatedState);
}

FHyperTwistTrainingFriendLinkRecord UHyperTwistTrainingRepositoryLibrary::ResolveFriendLinkRecordState(
	const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord,
	const EHyperTwistTrainingFriendLinkState State,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingFriendLinkRecord ResolvedRecord = FriendLinkRecord;
	const FString ResolvedUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	ResolvedRecord.State = State;
	if (ResolvedRecord.RequestedAtUtc.IsEmpty())
	{
		ResolvedRecord.RequestedAtUtc = ResolvedUtc;
	}
	if (State == EHyperTwistTrainingFriendLinkState::Active
		|| State == EHyperTwistTrainingFriendLinkState::Rejected)
	{
		ResolvedRecord.RespondedAtUtc = ResolvedUtc;
	}
	else if (State == EHyperTwistTrainingFriendLinkState::PendingIncoming
		|| State == EHyperTwistTrainingFriendLinkState::PendingOutgoing)
	{
		ResolvedRecord.RespondedAtUtc.Reset();
	}
	ResolvedRecord.LastUpdatedAtUtc = ResolvedUtc;
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(ResolvedRecord);
}

TArray<FHyperTwistTrainingNotificationRecord> UHyperTwistTrainingRepositoryLibrary::ListNotificationsForUser(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId
)
{
	if (UserId.IsEmpty())
	{
		return TArray<FHyperTwistTrainingNotificationRecord>();
	}

	TArray<FHyperTwistTrainingNotificationRecord> Notifications;
	for (const FHyperTwistTrainingNotificationRecord& NotificationRecord : RepositoryState.StoredNotifications)
	{
		const FHyperTwistTrainingNotificationRecord NormalizedNotificationRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeNotificationRecord(NotificationRecord);
		if (NormalizedNotificationRecord.IsStructurallyValid()
			&& NormalizedNotificationRecord.RecipientUserId == UserId)
		{
			Notifications.Add(NormalizedNotificationRecord);
		}
	}

	return HyperTwistTrainingRepositoryLibraryInternal::SortNotificationsByChangeUtc(Notifications);
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetNotificationRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& NotificationId,
	FHyperTwistTrainingNotificationRecord& OutNotificationRecord
)
{
	OutNotificationRecord = FHyperTwistTrainingNotificationRecord();
	if (NotificationId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingNotificationRecord* ExistingRecord =
		RepositoryState.StoredNotifications.FindByPredicate(
			[&NotificationId](const FHyperTwistTrainingNotificationRecord& NotificationRecord)
			{
				return NotificationRecord.NotificationId == NotificationId;
			}
		);
	if (ExistingRecord == nullptr)
	{
		return false;
	}

	OutNotificationRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeNotificationRecord(*ExistingRecord);
	return OutNotificationRecord.IsStructurallyValid();
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertNotificationRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingNotificationRecord& NotificationRecord
)
{
	FHyperTwistTrainingRepositoryState UpdatedState = RepositoryState;
	const FHyperTwistTrainingNotificationRecord NormalizedNotificationRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeNotificationRecord(NotificationRecord);
	if (!NormalizedNotificationRecord.IsStructurallyValid())
	{
		return UpdatedState;
	}

	const int32 ExistingIndex = UpdatedState.StoredNotifications.IndexOfByPredicate(
		[&NormalizedNotificationRecord](const FHyperTwistTrainingNotificationRecord& ExistingRecord)
		{
			return ExistingRecord.NotificationId == NormalizedNotificationRecord.NotificationId;
		}
	);
	if (ExistingIndex >= 0)
	{
		UpdatedState.StoredNotifications[ExistingIndex] = NormalizedNotificationRecord;
	}
	else
	{
		UpdatedState.StoredNotifications.Add(NormalizedNotificationRecord);
	}

	return RepairRepositoryState(UpdatedState);
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::MarkNotificationRead(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& NotificationId,
	const FString& ReadAtUtc
)
{
	FHyperTwistTrainingNotificationRecord NotificationRecord;
	if (!TryGetNotificationRecord(RepositoryState, NotificationId, NotificationRecord))
	{
		return RepositoryState;
	}

	NotificationRecord.ReadAtUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReadAtUtc);
	NotificationRecord.bRead = true;
	if (NotificationRecord.VisibilityState == EHyperTwistTrainingNotificationVisibilityState::Hidden)
	{
		NotificationRecord.VisibilityState = EHyperTwistTrainingNotificationVisibilityState::Inbox;
	}
	return UpsertNotificationRecord(RepositoryState, NotificationRecord);
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::AcknowledgeNotification(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& NotificationId,
	const FString& AcknowledgedAtUtc
)
{
	FHyperTwistTrainingNotificationRecord NotificationRecord;
	if (!TryGetNotificationRecord(RepositoryState, NotificationId, NotificationRecord))
	{
		return RepositoryState;
	}

	const FString ResolvedUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(AcknowledgedAtUtc);
	NotificationRecord.AcknowledgedAtUtc = ResolvedUtc;
	NotificationRecord.bAcknowledged = true;
	if (!NotificationRecord.bRead)
	{
		NotificationRecord.ReadAtUtc = ResolvedUtc;
		NotificationRecord.bRead = true;
	}
	return UpsertNotificationRecord(RepositoryState, NotificationRecord);
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::ArchiveNotification(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& NotificationId,
	const FString& ArchivedAtUtc
)
{
	FHyperTwistTrainingNotificationRecord NotificationRecord;
	if (!TryGetNotificationRecord(RepositoryState, NotificationId, NotificationRecord))
	{
		return RepositoryState;
	}

	NotificationRecord.ArchivedAtUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ArchivedAtUtc);
	NotificationRecord.VisibilityState = EHyperTwistTrainingNotificationVisibilityState::Archived;
	return UpsertNotificationRecord(RepositoryState, NotificationRecord);
}

TArray<FHyperTwistTrainingChallengeRecord> UHyperTwistTrainingRepositoryLibrary::ListChallengesForUser(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId
)
{
	if (UserId.IsEmpty())
	{
		return TArray<FHyperTwistTrainingChallengeRecord>();
	}

	TArray<FHyperTwistTrainingChallengeRecord> Challenges;
	for (const FHyperTwistTrainingChallengeRecord& ChallengeRecord : RepositoryState.StoredChallenges)
	{
		const FHyperTwistTrainingChallengeRecord NormalizedChallengeRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeChallengeRecord(ChallengeRecord);
		if (NormalizedChallengeRecord.IsStructurallyValid()
			&& (NormalizedChallengeRecord.ChallengerUserId == UserId
				|| NormalizedChallengeRecord.RecipientUserId == UserId))
		{
			Challenges.Add(NormalizedChallengeRecord);
		}
	}

	return HyperTwistTrainingRepositoryLibraryInternal::SortChallengesByUpdateUtc(Challenges);
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetChallengeRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& ChallengeId,
	FHyperTwistTrainingChallengeRecord& OutChallengeRecord
)
{
	OutChallengeRecord = FHyperTwistTrainingChallengeRecord();
	if (ChallengeId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingChallengeRecord* ExistingRecord =
		RepositoryState.StoredChallenges.FindByPredicate(
			[&ChallengeId](const FHyperTwistTrainingChallengeRecord& ChallengeRecord)
			{
				return ChallengeRecord.ChallengeId == ChallengeId;
			}
		);
	if (ExistingRecord == nullptr)
	{
		return false;
	}

	OutChallengeRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeChallengeRecord(*ExistingRecord);
	return OutChallengeRecord.IsStructurallyValid();
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertChallengeRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingChallengeRecord& ChallengeRecord
)
{
	FHyperTwistTrainingRepositoryState UpdatedState = RepositoryState;
	const FHyperTwistTrainingChallengeRecord NormalizedChallengeRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeChallengeRecord(ChallengeRecord);
	if (!NormalizedChallengeRecord.IsStructurallyValid())
	{
		return UpdatedState;
	}

	const int32 ExistingIndex = UpdatedState.StoredChallenges.IndexOfByPredicate(
		[&NormalizedChallengeRecord](const FHyperTwistTrainingChallengeRecord& ExistingRecord)
		{
			return ExistingRecord.ChallengeId == NormalizedChallengeRecord.ChallengeId;
		}
	);
	if (ExistingIndex >= 0)
	{
		UpdatedState.StoredChallenges[ExistingIndex] = NormalizedChallengeRecord;
	}
	else
	{
		UpdatedState.StoredChallenges.Add(NormalizedChallengeRecord);
	}

	return RepairRepositoryState(UpdatedState);
}

FHyperTwistTrainingChallengeRecord UHyperTwistTrainingRepositoryLibrary::ResolveChallengeRecordState(
	const FHyperTwistTrainingChallengeRecord& ChallengeRecord,
	const EHyperTwistTrainingChallengeLifecycleState LifecycleState,
	const EHyperTwistTrainingLocalMatchReadinessState MatchReadinessState,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingChallengeRecord ResolvedRecord = ChallengeRecord;
	const FString ResolvedUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	ResolvedRecord.LifecycleState = LifecycleState;
	ResolvedRecord.MatchReadinessState = MatchReadinessState;
	if (ResolvedRecord.CreatedAtUtc.IsEmpty())
	{
		ResolvedRecord.CreatedAtUtc = ResolvedUtc;
	}
	if (LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Accepted
		|| LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Rejected)
	{
		ResolvedRecord.RespondedAtUtc = ResolvedUtc;
	}
	if (LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Ready)
	{
		ResolvedRecord.ReadyAtUtc = ResolvedUtc;
	}
	if (LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Completed)
	{
		ResolvedRecord.CompletedAtUtc = ResolvedUtc;
	}
	if (LifecycleState == EHyperTwistTrainingChallengeLifecycleState::Expired
		&& ResolvedRecord.ExpiresAtUtc.IsEmpty())
	{
		ResolvedRecord.ExpiresAtUtc = ResolvedUtc;
	}
	ResolvedRecord.LastUpdatedAtUtc = ResolvedUtc;
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeChallengeRecord(ResolvedRecord);
}

FHyperTwistTrainingChallengeComparisonBundle UHyperTwistTrainingRepositoryLibrary::BuildChallengeComparisonBundle(
	const FHyperTwistTrainingChallengeRecord& ChallengeRecord
)
{
	FHyperTwistTrainingChallengeComparisonBundle Bundle;
	const FHyperTwistTrainingChallengeRecord NormalizedChallengeRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeChallengeRecord(ChallengeRecord);
	if (!NormalizedChallengeRecord.IsStructurallyValid())
	{
		return Bundle;
	}

	Bundle.ChallengeId = NormalizedChallengeRecord.ChallengeId;
	Bundle.DeckId = NormalizedChallengeRecord.DeckId;
	Bundle.EventId = NormalizedChallengeRecord.EventId;
	Bundle.LifecycleLabel = HyperTwistTrainingRepositoryLibraryInternal::FormatChallengeLifecycleLabel(
		NormalizedChallengeRecord.LifecycleState
	);
	Bundle.MatchReadinessLabel =
		HyperTwistTrainingRepositoryLibraryInternal::FormatChallengeReadinessLabel(
			NormalizedChallengeRecord.MatchReadinessState
		);
	Bundle.bReadyToCompare = HyperTwistTrainingRepositoryLibraryInternal::IsReadyChallenge(
		NormalizedChallengeRecord
	);

	FHyperTwistTrainingLeaderboardEventReference EventReference;
	const bool bHasEventReference = UHyperTwistTrainingKnowledgeLibrary::TryGetHypercubingLeaderboardEvent(
		NormalizedChallengeRecord.EventId,
		EventReference
	);
	Bundle.EventTitle = bHasEventReference
		? EventReference.Title
		: (!NormalizedChallengeRecord.ChallengerSnapshot.ReferenceEntry.EventTitle.IsEmpty()
			? NormalizedChallengeRecord.ChallengerSnapshot.ReferenceEntry.EventTitle
			: (!NormalizedChallengeRecord.RecipientSnapshot.ReferenceEntry.EventTitle.IsEmpty()
				? NormalizedChallengeRecord.RecipientSnapshot.ReferenceEntry.EventTitle
				: NormalizedChallengeRecord.Title));
	Bundle.MetricLabel = bHasEventReference
		? EventReference.MetricLabel
		: (!NormalizedChallengeRecord.ChallengerSnapshot.ReferenceEntry.MetricLabel.IsEmpty()
			? NormalizedChallengeRecord.ChallengerSnapshot.ReferenceEntry.MetricLabel
			: (!NormalizedChallengeRecord.RecipientSnapshot.ReferenceEntry.MetricLabel.IsEmpty()
				? NormalizedChallengeRecord.RecipientSnapshot.ReferenceEntry.MetricLabel
				: TEXT("Result")));

	const auto BuildComparisonEntry = [&](
		const FHyperTwistTrainingChallengeParticipantSnapshot& ParticipantSnapshot,
		const bool bCurrentUser
	)
	{
		FHyperTwistTrainingChallengeComparisonEntry Entry;
		Entry.UserId = ParticipantSnapshot.UserId;
		Entry.DisplayName = ParticipantSnapshot.DisplayName;
		Entry.EventId = NormalizedChallengeRecord.EventId;
		Entry.EventTitle = Bundle.EventTitle;
		Entry.MetricLabel = Bundle.MetricLabel;
		Entry.MetricPrimaryValue = ParticipantSnapshot.ReferenceEntry.MetricPrimaryValue;
		Entry.MetricSecondaryValue = ParticipantSnapshot.ReferenceEntry.MetricSecondaryValue;
		Entry.RelativeDateLabel = !ParticipantSnapshot.ReferenceEntry.RecordedAtUtc.IsEmpty()
			? UHyperTwistTrainingKnowledgeLibrary::FormatHypercubingLeaderboardRelativeDateLabel(
				ParticipantSnapshot.ReferenceEntry.RecordedAtUtc
			)
			: TEXT("n/a");
		Entry.ProgramLabel = !ParticipantSnapshot.ReferenceEntry.ProgramLabel.IsEmpty()
			? ParticipantSnapshot.ReferenceEntry.ProgramLabel
			: (bHasEventReference && EventReference.PreferredProgramIds.Num() > 0
				? UHyperTwistTrainingKnowledgeLibrary::ResolveHypercubingProgramBadge(
					EventReference.PreferredProgramIds[0]
				)
				: TEXT("Local"));
		Entry.DeckId = ParticipantSnapshot.DeckId;
		Entry.bCurrentUser = bCurrentUser;
		Entry.bHasComparableEntry = !Entry.MetricPrimaryValue.IsEmpty();
		return Entry;
	};

	const FHyperTwistTrainingChallengeComparisonEntry ChallengerEntry = BuildComparisonEntry(
		NormalizedChallengeRecord.ChallengerSnapshot,
		false
	);
	if (ChallengerEntry.IsStructurallyValid())
	{
		Bundle.Entries.Add(ChallengerEntry);
	}

	const FHyperTwistTrainingChallengeComparisonEntry RecipientEntry = BuildComparisonEntry(
		NormalizedChallengeRecord.RecipientSnapshot,
		false
	);
	if (RecipientEntry.IsStructurallyValid())
	{
		Bundle.Entries.Add(RecipientEntry);
	}

	return Bundle;
}

FHyperTwistTrainingSocialChallengeBundle UHyperTwistTrainingRepositoryLibrary::DeriveSocialChallengeBundle(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc,
	const FHyperTwistTrainingEntitlementGateState& EntitlementGateState
)
{
	FHyperTwistTrainingSocialChallengeBundle Bundle;
	if (UserId.IsEmpty())
	{
		return Bundle;
	}

	Bundle.UserId = UserId;
	Bundle.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	Bundle.GateId = EntitlementGateState.GateId;
	Bundle.FeatureId = EntitlementGateState.FeatureId;
	Bundle.VisibilityLabel = !EntitlementGateState.VisibilityLabel.IsEmpty()
		? EntitlementGateState.VisibilityLabel
		: (EntitlementGateState.bVisible ? TEXT("visible") : TEXT("hidden"));
	Bundle.bVisible = EntitlementGateState.bVisible;
	Bundle.bChallengeCreationEnabled = EntitlementGateState.bVisible && EntitlementGateState.bEntitled;
	Bundle.FriendLinks = ListFriendLinksForUser(RepositoryState, UserId);
	Bundle.Notifications = ListNotificationsForUser(RepositoryState, UserId);
	Bundle.Challenges = ListChallengesForUser(RepositoryState, UserId);

	for (const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord : Bundle.FriendLinks)
	{
		if (FriendLinkRecord.State == EHyperTwistTrainingFriendLinkState::PendingIncoming
			|| FriendLinkRecord.State == EHyperTwistTrainingFriendLinkState::PendingOutgoing)
		{
			Bundle.PendingFriendCount += 1;
		}
	}

	for (const FHyperTwistTrainingNotificationRecord& NotificationRecord : Bundle.Notifications)
	{
		if (NotificationRecord.VisibilityState == EHyperTwistTrainingNotificationVisibilityState::Inbox)
		{
			Bundle.VisibleNotificationCount += 1;
			if (!NotificationRecord.bRead)
			{
				Bundle.UnreadNotificationCount += 1;
			}
		}
		if (NotificationRecord.bAcknowledged)
		{
			Bundle.AcknowledgedNotificationCount += 1;
		}
		if (NotificationRecord.VisibilityState == EHyperTwistTrainingNotificationVisibilityState::Archived)
		{
			Bundle.ArchivedNotificationCount += 1;
		}
	}

	for (const FHyperTwistTrainingChallengeRecord& ChallengeRecord : Bundle.Challenges)
	{
		if (HyperTwistTrainingRepositoryLibraryInternal::IsActiveChallenge(ChallengeRecord))
		{
			Bundle.ActiveChallengeCount += 1;
		}
		if (HyperTwistTrainingRepositoryLibraryInternal::IsReadyChallenge(ChallengeRecord))
		{
			Bundle.ReadyChallengeCount += 1;
		}

		const FHyperTwistTrainingChallengeComparisonBundle ComparisonBundle =
			BuildChallengeComparisonBundle(ChallengeRecord);
		if (ComparisonBundle.IsStructurallyValid())
		{
			FHyperTwistTrainingChallengeComparisonBundle UserComparisonBundle = ComparisonBundle;
			for (FHyperTwistTrainingChallengeComparisonEntry& Entry : UserComparisonBundle.Entries)
			{
				Entry.bCurrentUser = Entry.UserId == UserId;
			}
			Bundle.ComparisonBundles.Add(UserComparisonBundle);
		}
	}

	return Bundle;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertSmartDeviceSessionRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord
)
{
	FHyperTwistTrainingRepositoryState UpdatedState = RepositoryState;
	const FHyperTwistTrainingSmartDeviceSessionRecord NormalizedSessionRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceSessionRecord(SessionRecord);
	if (!NormalizedSessionRecord.IsStructurallyValid())
	{
		return UpdatedState;
	}

	const int32 ExistingIndex = UpdatedState.StoredSmartDeviceSessions.IndexOfByPredicate(
		[&NormalizedSessionRecord](const FHyperTwistTrainingSmartDeviceSessionRecord& ExistingRecord)
		{
			return ExistingRecord.DeviceSessionId == NormalizedSessionRecord.DeviceSessionId;
		}
	);
	if (ExistingIndex >= 0)
	{
		UpdatedState.StoredSmartDeviceSessions[ExistingIndex] = NormalizedSessionRecord;
	}
	else
	{
		UpdatedState.StoredSmartDeviceSessions.Add(NormalizedSessionRecord);
	}

	return RepairRepositoryState(UpdatedState);
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetSmartDeviceSessionRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& DeviceSessionId,
	FHyperTwistTrainingSmartDeviceSessionRecord& OutSessionRecord
)
{
	OutSessionRecord = FHyperTwistTrainingSmartDeviceSessionRecord();
	if (DeviceSessionId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingSmartDeviceSessionRecord* ExistingRecord =
		RepositoryState.StoredSmartDeviceSessions.FindByPredicate(
			[&DeviceSessionId](const FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord)
			{
				return SessionRecord.DeviceSessionId == DeviceSessionId;
			}
		);
	if (ExistingRecord == nullptr)
	{
		return false;
	}

	OutSessionRecord =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceSessionRecord(*ExistingRecord);
	return OutSessionRecord.IsStructurallyValid();
}

bool UHyperTwistTrainingRepositoryLibrary::HasSmartDeviceEventFrame(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& DeviceSessionId,
	const FString& EventId
)
{
	if (DeviceSessionId.IsEmpty() || EventId.IsEmpty())
	{
		return false;
	}

	const FString EventKey = FString::Printf(TEXT("%s\x1f%s"), *DeviceSessionId, *EventId);
	return RepositoryState.StoredSmartDeviceEventFrames.ContainsByPredicate(
		[&EventKey](const FHyperTwistTrainingSmartDeviceEventFrame& EventFrame)
		{
			return HyperTwistTrainingRepositoryLibraryInternal::BuildSmartDeviceEventKey(
				HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceEventFrame(EventFrame)
			) == EventKey;
		}
	);
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::RecordSmartDeviceEventFrame(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingSmartDeviceEventFrame& EventFrame
)
{
	FHyperTwistTrainingRepositoryState UpdatedState = RepositoryState;
	const FHyperTwistTrainingSmartDeviceEventFrame NormalizedEventFrame =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceEventFrame(EventFrame);
	const FString EventKey =
		HyperTwistTrainingRepositoryLibraryInternal::BuildSmartDeviceEventKey(NormalizedEventFrame);
	if (!NormalizedEventFrame.IsStructurallyValid() || EventKey.IsEmpty())
	{
		return UpdatedState;
	}

	const int32 ExistingIndex = UpdatedState.StoredSmartDeviceEventFrames.IndexOfByPredicate(
		[&EventKey](const FHyperTwistTrainingSmartDeviceEventFrame& ExistingFrame)
		{
			return HyperTwistTrainingRepositoryLibraryInternal::BuildSmartDeviceEventKey(
				HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceEventFrame(ExistingFrame)
			) == EventKey;
		}
	);
	if (ExistingIndex >= 0)
	{
		UpdatedState.StoredSmartDeviceEventFrames[ExistingIndex] = NormalizedEventFrame;
	}
	else
	{
		UpdatedState.StoredSmartDeviceEventFrames.Add(NormalizedEventFrame);
	}

	return RepairRepositoryState(UpdatedState);
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertRunRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingRunRecord& RunRecord
)
{
	FHyperTwistTrainingRepositoryState UpdatedState = RepositoryState;
	if (!RunRecord.IsStructurallyValid())
	{
		return UpdatedState;
	}

	const int32 ExistingIndex = UpdatedState.RunRecords.IndexOfByPredicate(
		[&RunRecord](const FHyperTwistTrainingRunRecord& ExistingRecord)
		{
			return ExistingRecord.Session.TrainingSessionId == RunRecord.Session.TrainingSessionId;
		}
	);

	if (ExistingIndex >= 0)
	{
		UpdatedState.RunRecords[ExistingIndex] = RunRecord;
	}
	else
	{
		UpdatedState.RunRecords.Add(RunRecord);
	}

	UpdatedState.LearnerStates = HyperTwistTrainingRepositoryLibraryInternal::BuildLearnerStates(UpdatedState.RunRecords);
	return UpdatedState;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::RecordRunState(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingRunState& RunState
)
{
	return UpsertRunRecord(RepositoryState, BuildRunRecord(RunState));
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetRunRecord(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& TrainingSessionId,
	FHyperTwistTrainingRunRecord& OutRunRecord
)
{
	OutRunRecord = FHyperTwistTrainingRunRecord();
	if (TrainingSessionId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingRunRecord* ExistingRecord = RepositoryState.RunRecords.FindByPredicate(
		[&TrainingSessionId](const FHyperTwistTrainingRunRecord& RunRecord)
		{
			return RunRecord.Session.TrainingSessionId == TrainingSessionId;
		}
	);

	if (ExistingRecord == nullptr)
	{
		return false;
	}

	OutRunRecord = *ExistingRecord;
	return OutRunRecord.IsStructurallyValid();
}

TArray<FHyperTwistTrainingRunRecord> UHyperTwistTrainingRepositoryLibrary::ListRunRecordsForDeck(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId
)
{
	TArray<FHyperTwistTrainingRunRecord> Records;
	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (!RunRecord.IsStructurallyValid())
		{
			continue;
		}

		const bool bMatchesUser = UserId.IsEmpty() || RunRecord.Session.UserId == UserId;
		const bool bMatchesDeck = DeckId.IsEmpty() || RunRecord.Session.DeckId == DeckId;
		if (bMatchesUser && bMatchesDeck)
		{
			Records.Add(RunRecord);
		}
	}

	Records.Sort([](const FHyperTwistTrainingRunRecord& Left, const FHyperTwistTrainingRunRecord& Right)
	{
		return HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(Left.LastUpdatedAtUtc, Right.LastUpdatedAtUtc) > 0;
	});

	return Records;
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetLatestGeneratedModeLaunchRequestForDeck(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	FHyperTwistTrainingImportedGeneratedModeLaunchRequest& OutLaunchRequest
)
{
	OutLaunchRequest = FHyperTwistTrainingImportedGeneratedModeLaunchRequest();
	const TArray<FHyperTwistTrainingRunRecord> Records = ListRunRecordsForDeck(RepositoryState, UserId, DeckId);
	for (const FHyperTwistTrainingRunRecord& RunRecord : Records)
	{
		if (!RunRecord.IsStructurallyValid())
		{
			continue;
		}

		if (RunRecord.ImportedGeneratedModeLaunchRequest.IsStructurallyValid())
		{
			OutLaunchRequest = RunRecord.ImportedGeneratedModeLaunchRequest;
			return true;
		}
	}

	return false;
}

FHyperTwistTrainingCaseLearnerState UHyperTwistTrainingRepositoryLibrary::DeriveLearnerStateForCase(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& CaseId
)
{
	FHyperTwistTrainingCaseLearnerState LearnerState;
	if (TryGetLearnerState(RepositoryState, UserId, DeckId, CaseId, LearnerState))
	{
		return LearnerState;
	}

	const TMap<FString, TArray<FHyperTwistTrainingReviewHistoryEntry>> ReviewHistoryByCase =
		HyperTwistTrainingRepositoryLibraryInternal::BuildReviewHistoryByCase(RepositoryState.RunRecords);
	const FString CaseKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCaseKey(UserId, DeckId, CaseId);
	const TArray<FHyperTwistTrainingReviewHistoryEntry>* ExistingReviewHistory = ReviewHistoryByCase.Find(CaseKey);
	if (ExistingReviewHistory == nullptr)
	{
		return FHyperTwistTrainingCaseLearnerState();
	}

	return HyperTwistTrainingRepositoryLibraryInternal::DeriveLearnerStateFromReviewHistory(
		UserId,
		DeckId,
		CaseId,
		*ExistingReviewHistory
	);
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetLearnerState(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& CaseId,
	FHyperTwistTrainingCaseLearnerState& OutLearnerState
)
{
	OutLearnerState = FHyperTwistTrainingCaseLearnerState();
	if (CaseId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingCaseLearnerState* ExistingLearnerState = RepositoryState.LearnerStates.FindByPredicate(
		[&UserId, &DeckId, &CaseId](const FHyperTwistTrainingCaseLearnerState& Candidate)
		{
			return Candidate.UserId == UserId
				&& Candidate.DeckId == DeckId
				&& Candidate.CaseId == CaseId;
		}
	);

	if (ExistingLearnerState == nullptr)
	{
		return false;
	}

	OutLearnerState = *ExistingLearnerState;
	return OutLearnerState.IsStructurallyValid();
}

TArray<FHyperTwistTrainingCaseLearnerState> UHyperTwistTrainingRepositoryLibrary::ListLearnerStatesForDeck(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId
)
{
	const TArray<FHyperTwistTrainingCaseLearnerState> SourceStates = RepositoryState.LearnerStates.Num() > 0
		? RepositoryState.LearnerStates
		: HyperTwistTrainingRepositoryLibraryInternal::BuildLearnerStates(RepositoryState.RunRecords);

	TArray<FHyperTwistTrainingCaseLearnerState> LearnerStates;
	for (const FHyperTwistTrainingCaseLearnerState& LearnerState : SourceStates)
	{
		if (!LearnerState.IsStructurallyValid())
		{
			continue;
		}

		const bool bMatchesUser = UserId.IsEmpty() || LearnerState.UserId == UserId;
		const bool bMatchesDeck = DeckId.IsEmpty() || LearnerState.DeckId == DeckId;
		if (bMatchesUser && bMatchesDeck)
		{
			LearnerStates.Add(LearnerState);
		}
	}

	LearnerStates.Sort([](const FHyperTwistTrainingCaseLearnerState& Left, const FHyperTwistTrainingCaseLearnerState& Right)
	{
		const int32 DueCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(Left.DueAtUtc, Right.DueAtUtc);
		if (DueCompare != 0)
		{
			return DueCompare < 0;
		}

		return Left.CaseId < Right.CaseId;
	});

	return LearnerStates;
}

FHyperTwistTrainingDeckHistorySummary UHyperTwistTrainingRepositoryLibrary::DeriveDeckHistorySummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId
)
{
	FHyperTwistTrainingDeckHistorySummary Summary;
	Summary.UserId = UserId;
	Summary.DeckId = DeckId;

	const TArray<FHyperTwistTrainingRunRecord> Records = ListRunRecordsForDeck(RepositoryState, UserId, DeckId);
	int64 TotalTimeAccumulator = 0;
	int64 RawSolveAccumulator = 0;
	int64 InspectionAccumulator = 0;
	int32 TotalTimedAttempts = 0;
	int32 RawSolveSamples = 0;
	int32 InspectionSamples = 0;

	for (const FHyperTwistTrainingRunRecord& RunRecord : Records)
	{
		Summary.SessionCount += 1;
		if (RunRecord.bCompleted)
		{
			Summary.CompletedSessionCount += 1;
		}

		Summary.TotalAttemptCount += RunRecord.Summary.AttemptCount;
		Summary.SuccessCount += RunRecord.Summary.SuccessCount;
		Summary.FailureCount += RunRecord.Summary.FailureCount;
		Summary.TimeoutCount += RunRecord.Summary.TimeoutCount;
		Summary.DNFCount += RunRecord.Summary.DNFCount;
		Summary.AbortedCount += RunRecord.Summary.AbortedCount;
		Summary.Plus2PenaltyCount += RunRecord.Summary.Plus2PenaltyCount;

		for (const FHyperTwistTrainingSolveHistoryEntry& SolveEntry : RunRecord.SolveHistory)
		{
			if (SolveEntry.TotalTimeMs <= 0)
			{
				continue;
			}

			TotalTimeAccumulator += SolveEntry.TotalTimeMs;
			TotalTimedAttempts += 1;

			if (Summary.BestTotalTimeMs == 0 || SolveEntry.TotalTimeMs < Summary.BestTotalTimeMs)
			{
				Summary.BestTotalTimeMs = SolveEntry.TotalTimeMs;
			}

			if (SolveEntry.TimingBreakdown.RawSolveTimeMs > 0)
			{
				RawSolveAccumulator += SolveEntry.TimingBreakdown.RawSolveTimeMs;
				RawSolveSamples += 1;
				if (Summary.BestRawSolveTimeMs == 0 || SolveEntry.TimingBreakdown.RawSolveTimeMs < Summary.BestRawSolveTimeMs)
				{
					Summary.BestRawSolveTimeMs = SolveEntry.TimingBreakdown.RawSolveTimeMs;
				}
			}

			if (SolveEntry.TimingBreakdown.InspectionElapsedMs > 0)
			{
				InspectionAccumulator += SolveEntry.TimingBreakdown.InspectionElapsedMs;
				InspectionSamples += 1;
			}
		}

		if (Summary.LastSessionId.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(RunRecord.LastUpdatedAtUtc, Summary.LastCompletedAtUtc) > 0)
		{
			Summary.LastSessionId = RunRecord.Session.TrainingSessionId;
			Summary.LastCompletedAtUtc = RunRecord.LastUpdatedAtUtc;
		}
	}

	if (TotalTimedAttempts > 0)
	{
		Summary.AverageTotalTimeMs = static_cast<int32>(TotalTimeAccumulator / TotalTimedAttempts);
	}

	if (RawSolveSamples > 0)
	{
		Summary.AverageRawSolveTimeMs = static_cast<int32>(RawSolveAccumulator / RawSolveSamples);
	}

	if (InspectionSamples > 0)
	{
		Summary.AverageInspectionTimeMs = static_cast<int32>(InspectionAccumulator / InspectionSamples);
	}

	return Summary;
}

FHyperTwistTrainingTimingTrendSummary UHyperTwistTrainingRepositoryLibrary::DeriveTimingTrendSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingTimingTrendSummary Summary;
	if (UserId.IsEmpty() || DeckId.IsEmpty())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.DeckId = DeckId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingRunRecord> RunRecords = ListRunRecordsForDeck(RepositoryState, UserId, DeckId);
	const TArray<HyperTwistTrainingRepositoryLibraryInternal::FTimedSolveSample> TimedSolveSamples =
		HyperTwistTrainingRepositoryLibraryInternal::BuildTimedSolveSamples(RunRecords);
	Summary.SolveCount = TimedSolveSamples.Num();
	if (TimedSolveSamples.Num() == 0)
	{
		return Summary;
	}

	const HyperTwistTrainingRepositoryLibraryInternal::FTimedSolveSample& LastSolveSample = TimedSolveSamples.Last();
	Summary.LastSolveTotalTimeMs = LastSolveSample.TotalTimeMs;
	Summary.LastSolveRawSolveTimeMs = LastSolveSample.RawSolveTimeMs;
	Summary.LastSolveAtUtc = LastSolveSample.RecordedAtUtc;

	int64 TotalTimeAccumulator = 0;
	int64 RawSolveTimeAccumulator = 0;
	for (const HyperTwistTrainingRepositoryLibraryInternal::FTimedSolveSample& TimedSolveSample : TimedSolveSamples)
	{
		TotalTimeAccumulator += TimedSolveSample.TotalTimeMs;
		RawSolveTimeAccumulator += TimedSolveSample.RawSolveTimeMs;

		if (Summary.BestSingleTotalTimeMs == 0 || TimedSolveSample.TotalTimeMs < Summary.BestSingleTotalTimeMs)
		{
			Summary.BestSingleTotalTimeMs = TimedSolveSample.TotalTimeMs;
		}
		Summary.WorstSingleTotalTimeMs = FMath::Max(Summary.WorstSingleTotalTimeMs, TimedSolveSample.TotalTimeMs);

		if (Summary.BestSingleRawSolveTimeMs == 0 || TimedSolveSample.RawSolveTimeMs < Summary.BestSingleRawSolveTimeMs)
		{
			Summary.BestSingleRawSolveTimeMs = TimedSolveSample.RawSolveTimeMs;
		}
		Summary.WorstSingleRawSolveTimeMs =
			FMath::Max(Summary.WorstSingleRawSolveTimeMs, TimedSolveSample.RawSolveTimeMs);
	}

	Summary.MeanTotalTimeMs = static_cast<int32>(TotalTimeAccumulator / TimedSolveSamples.Num());
	Summary.MeanRawSolveTimeMs = static_cast<int32>(RawSolveTimeAccumulator / TimedSolveSamples.Num());

	for (const int32 WindowSize : {3, 5, 12, 50, 100, 1000})
	{
		Summary.RollingWindows.Add(HyperTwistTrainingRepositoryLibraryInternal::BuildRollingWindowStat(
			TimedSolveSamples,
			WindowSize
		));
	}

	return Summary;
}

FHyperTwistTrainingPersonalBestSummary UHyperTwistTrainingRepositoryLibrary::DerivePersonalBestSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingPersonalBestSummary Summary;
	if (UserId.IsEmpty() || DeckId.IsEmpty())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.DeckId = DeckId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingRunRecord> SortedRunRecords =
		HyperTwistTrainingRepositoryLibraryInternal::SortRunRecordsByUpdateUtc(
			ListRunRecordsForDeck(RepositoryState, UserId, DeckId)
		);
	for (const FHyperTwistTrainingRunRecord& RunRecord : SortedRunRecords)
	{
		if (!RunRecord.IsStructurallyValid())
		{
			continue;
		}

		for (const FHyperTwistTrainingSolveHistoryEntry& SolveEntry : RunRecord.SolveHistory)
		{
			if (!HyperTwistTrainingRepositoryLibraryInternal::IsTimedSolveEntry(SolveEntry))
			{
				continue;
			}

			bool bSingleBestImproved = false;
			if (Summary.BestSingleTotalTimeMs == 0 || SolveEntry.TotalTimeMs < Summary.BestSingleTotalTimeMs)
			{
				Summary.BestSingleTotalTimeMs = SolveEntry.TotalTimeMs;
				bSingleBestImproved = true;
			}

			if (Summary.BestSingleRawSolveTimeMs == 0
				|| SolveEntry.TimingBreakdown.RawSolveTimeMs < Summary.BestSingleRawSolveTimeMs)
			{
				Summary.BestSingleRawSolveTimeMs = SolveEntry.TimingBreakdown.RawSolveTimeMs;
				bSingleBestImproved = true;
			}

			if (bSingleBestImproved)
			{
				Summary.BestSingleSessionId = RunRecord.Session.TrainingSessionId;
				Summary.LastPersonalBestAtUtc = SolveEntry.RecordedAtUtc;
				Summary.bHasTimedPersonalBest = true;
			}
		}

		const bool bHasTimedSessionAverage =
			RunRecord.Summary.AverageTotalTimeMs > 0 && RunRecord.Summary.AverageRawSolveTimeMs > 0;
		if (!bHasTimedSessionAverage)
		{
			continue;
		}

		bool bAverageBestImproved = false;
		if (Summary.BestSessionAverageTotalTimeMs == 0
			|| RunRecord.Summary.AverageTotalTimeMs < Summary.BestSessionAverageTotalTimeMs)
		{
			Summary.BestSessionAverageTotalTimeMs = RunRecord.Summary.AverageTotalTimeMs;
			bAverageBestImproved = true;
		}

		if (Summary.BestSessionAverageRawSolveTimeMs == 0
			|| RunRecord.Summary.AverageRawSolveTimeMs < Summary.BestSessionAverageRawSolveTimeMs)
		{
			Summary.BestSessionAverageRawSolveTimeMs = RunRecord.Summary.AverageRawSolveTimeMs;
			bAverageBestImproved = true;
		}

		if (bAverageBestImproved)
		{
			Summary.BestAverageSessionId = RunRecord.Session.TrainingSessionId;
			Summary.LastPersonalBestAtUtc = !RunRecord.Session.EndedAtUtc.IsEmpty()
				? RunRecord.Session.EndedAtUtc
				: RunRecord.LastUpdatedAtUtc;
			Summary.bHasTimedPersonalBest = true;
		}
	}

	return Summary;
}

FHyperTwistTrainingTimerExportPacket UHyperTwistTrainingRepositoryLibrary::ExportTimerResultsForDeck(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingTimerExportPacket TimerExportPacket;
	if (UserId.IsEmpty() || DeckId.IsEmpty())
	{
		return TimerExportPacket;
	}

	TimerExportPacket.UserId = UserId;
	TimerExportPacket.DeckId = DeckId;
	TimerExportPacket.ExportedAtUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingRunRecord> SortedRunRecords =
		HyperTwistTrainingRepositoryLibraryInternal::SortRunRecordsByUpdateUtc(
			ListRunRecordsForDeck(RepositoryState, UserId, DeckId)
		);
	for (const FHyperTwistTrainingRunRecord& RunRecord : SortedRunRecords)
	{
		if (!RunRecord.IsStructurallyValid())
		{
			continue;
		}

		TArray<FHyperTwistTrainingAttemptHistoryEntry> SortedAttemptHistory = RunRecord.AttemptHistory;
		SortedAttemptHistory.Sort([](const FHyperTwistTrainingAttemptHistoryEntry& Left, const FHyperTwistTrainingAttemptHistoryEntry& Right)
		{
			const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				Left.RecordedAtUtc,
				Right.RecordedAtUtc
			);
			if (UtcCompare != 0)
			{
				return UtcCompare < 0;
			}

			return Left.AttemptId < Right.AttemptId;
		});

		for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptHistoryEntry : SortedAttemptHistory)
		{
			if (!AttemptHistoryEntry.IsStructurallyValid()
				|| !(AttemptHistoryEntry.bTimerOnly || AttemptHistoryEntry.DeliveryMode == EHyperTwistTrainingDeliveryMode::Timer))
			{
				continue;
			}

			FHyperTwistTrainingTimerExportEntry TimerExportEntry;
			TimerExportEntry.AttemptId = AttemptHistoryEntry.AttemptId;
			TimerExportEntry.TrainingSessionId = AttemptHistoryEntry.TrainingSessionId;
			TimerExportEntry.UserId = UserId;
			TimerExportEntry.DeckId = DeckId;
			TimerExportEntry.CaseId = AttemptHistoryEntry.CaseId;
			TimerExportEntry.RecordedAtUtc = AttemptHistoryEntry.RecordedAtUtc;
			TimerExportEntry.Result = AttemptHistoryEntry.Result;
			TimerExportEntry.TotalTimeMs = AttemptHistoryEntry.TotalTimeMs;
			TimerExportEntry.ExecutionTimeMs = AttemptHistoryEntry.ExecutionTimeMs;
			TimerExportEntry.RecognitionTimeMs = AttemptHistoryEntry.RecognitionTimeMs;
			TimerExportEntry.TimingBreakdown = AttemptHistoryEntry.TimingBreakdown;
			TimerExportEntry.ReplayId = AttemptHistoryEntry.ReplayId;
			TimerExportPacket.Entries.Add(TimerExportEntry);
		}
	}

	return NormalizeTimerExportPacket(TimerExportPacket);
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::ImportTimerResults(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingTimerExportPacket& TimerExportPacket
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	const FHyperTwistTrainingTimerExportPacket NormalizedPacket = NormalizeTimerExportPacket(TimerExportPacket);
	if (!NormalizedPacket.IsStructurallyValid())
	{
		return UpdatedRepositoryState;
	}

	TMap<FString, TArray<FHyperTwistTrainingTimerExportEntry>> EntriesBySessionId;
	for (const FHyperTwistTrainingTimerExportEntry& TimerExportEntry : NormalizedPacket.Entries)
	{
		if (!TimerExportEntry.IsStructurallyValid())
		{
			continue;
		}

		EntriesBySessionId.FindOrAdd(TimerExportEntry.TrainingSessionId).Add(TimerExportEntry);
	}

	for (const TPair<FString, TArray<FHyperTwistTrainingTimerExportEntry>>& Pair : EntriesBySessionId)
	{
		const FString& SessionId = Pair.Key;
		const TArray<FHyperTwistTrainingTimerExportEntry>& SessionEntries = Pair.Value;
		if (SessionId.IsEmpty() || SessionEntries.Num() == 0)
		{
			continue;
		}

		FHyperTwistTrainingRunRecord ImportedRunRecord =
			HyperTwistTrainingRepositoryLibraryInternal::BuildRunRecordFromTimerExportEntries(
				NormalizedPacket.UserId,
				NormalizedPacket.DeckId,
				SessionId,
				SessionEntries
			);
		UpdatedRepositoryState = UpsertRunRecord(UpdatedRepositoryState, ImportedRunRecord);
	}

	return RepairRepositoryState(UpdatedRepositoryState);
}

FHyperTwistTrainingTimerExportIntegrityReport UHyperTwistTrainingRepositoryLibrary::DeriveTimerExportIntegrityReport(
	const FHyperTwistTrainingTimerExportPacket& TimerExportPacket
)
{
	FHyperTwistTrainingTimerExportIntegrityReport Report;
	Report.UserId = TimerExportPacket.UserId;
	Report.DeckId = TimerExportPacket.DeckId;
	Report.TotalEntryCount = TimerExportPacket.Entries.Num();

	if (TimerExportPacket.FormatVersion.IsEmpty())
	{
		Report.MissingPacketMetadataCount += 1;
	}
	if (TimerExportPacket.SourceSystem.IsEmpty())
	{
		Report.MissingPacketMetadataCount += 1;
	}
	if (TimerExportPacket.UserId.IsEmpty())
	{
		Report.MissingPacketMetadataCount += 1;
	}
	if (TimerExportPacket.DeckId.IsEmpty())
	{
		Report.MissingPacketMetadataCount += 1;
	}
	if (TimerExportPacket.ExportedAtUtc.IsEmpty())
	{
		Report.MissingPacketMetadataCount += 1;
	}

	TSet<FString> SeenAttemptIds;
	for (const FHyperTwistTrainingTimerExportEntry& Entry : TimerExportPacket.Entries)
	{
		if (!Entry.IsStructurallyValid())
		{
			Report.InvalidEntryCount += 1;
			continue;
		}

		if (SeenAttemptIds.Contains(Entry.AttemptId))
		{
			Report.DuplicateEntryCount += 1;
		}
		else
		{
			SeenAttemptIds.Add(Entry.AttemptId);
		}

		const bool bScopeMismatch =
			(!TimerExportPacket.UserId.IsEmpty() && Entry.UserId != TimerExportPacket.UserId)
			|| (!TimerExportPacket.DeckId.IsEmpty() && Entry.DeckId != TimerExportPacket.DeckId);
		if (bScopeMismatch)
		{
			Report.MismatchedScopeEntryCount += 1;
		}
	}

	if (Report.MissingPacketMetadataCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("fill-missing-timer-export-metadata")
		);
	}
	if (Report.InvalidEntryCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-timer-export-entries")
		);
	}
	if (Report.DuplicateEntryCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("deduplicate-timer-export-attempt-ids")
		);
	}
	if (Report.MismatchedScopeEntryCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-mismatched-timer-export-scope-entries")
		);
	}

	return Report;
}

FHyperTwistTrainingTimerExportPacket UHyperTwistTrainingRepositoryLibrary::NormalizeTimerExportPacket(
	const FHyperTwistTrainingTimerExportPacket& TimerExportPacket
)
{
	FHyperTwistTrainingTimerExportPacket NormalizedPacket = TimerExportPacket;
	if (NormalizedPacket.FormatVersion.IsEmpty())
	{
		NormalizedPacket.FormatVersion = TEXT("ht-timer-export/v1");
	}
	if (NormalizedPacket.SourceSystem.IsEmpty())
	{
		NormalizedPacket.SourceSystem = TEXT("HyperTwistTraining");
	}
	if (NormalizedPacket.ExportedAtUtc.IsEmpty())
	{
		NormalizedPacket.ExportedAtUtc = FDateTime::UtcNow().ToIso8601();
	}

	FString ScopedUserId = NormalizedPacket.UserId;
	FString ScopedDeckId = NormalizedPacket.DeckId;
	if (ScopedUserId.IsEmpty() || ScopedDeckId.IsEmpty())
	{
		for (const FHyperTwistTrainingTimerExportEntry& Entry : TimerExportPacket.Entries)
		{
			if (!Entry.IsStructurallyValid())
			{
				continue;
			}

			if (ScopedUserId.IsEmpty())
			{
				ScopedUserId = Entry.UserId;
			}
			if (ScopedDeckId.IsEmpty())
			{
				ScopedDeckId = Entry.DeckId;
			}
			if (!ScopedUserId.IsEmpty() && !ScopedDeckId.IsEmpty())
			{
				break;
			}
		}
	}

	NormalizedPacket.UserId = ScopedUserId;
	NormalizedPacket.DeckId = ScopedDeckId;
	NormalizedPacket.Entries.Reset();

	TSet<FString> SeenAttemptIds;
	for (const FHyperTwistTrainingTimerExportEntry& Entry : TimerExportPacket.Entries)
	{
		if (!Entry.IsStructurallyValid())
		{
			continue;
		}
		if (!ScopedUserId.IsEmpty() && Entry.UserId != ScopedUserId)
		{
			continue;
		}
		if (!ScopedDeckId.IsEmpty() && Entry.DeckId != ScopedDeckId)
		{
			continue;
		}
		if (SeenAttemptIds.Contains(Entry.AttemptId))
		{
			continue;
		}

		SeenAttemptIds.Add(Entry.AttemptId);
		NormalizedPacket.Entries.Add(Entry);
	}

	return NormalizedPacket;
}

FHyperTwistTrainingRepositoryIntegrityReport UHyperTwistTrainingRepositoryLibrary::DeriveRepositoryIntegrityReport(
	const FHyperTwistTrainingRepositoryState& RepositoryState
)
{
	FHyperTwistTrainingRepositoryIntegrityReport Report;

	Report.TotalRunRecordCount = RepositoryState.RunRecords.Num();
	TSet<FString> SeenRunRecordIds;
	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (!RunRecord.IsStructurallyValid())
		{
			Report.InvalidRunRecordCount += 1;
			continue;
		}
		if (SeenRunRecordIds.Contains(RunRecord.Session.TrainingSessionId))
		{
			Report.DuplicateRunRecordCount += 1;
			continue;
		}

		SeenRunRecordIds.Add(RunRecord.Session.TrainingSessionId);
	}

	Report.TotalLearnerStateCount = RepositoryState.LearnerStates.Num();
	TSet<FString> SeenLearnerStateKeys;
	for (const FHyperTwistTrainingCaseLearnerState& LearnerState : RepositoryState.LearnerStates)
	{
		if (!LearnerState.IsStructurallyValid())
		{
			Report.InvalidLearnerStateCount += 1;
			continue;
		}

		const FString LearnerStateKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCaseKey(
			LearnerState.UserId,
			LearnerState.DeckId,
			LearnerState.CaseId
		);
		if (SeenLearnerStateKeys.Contains(LearnerStateKey))
		{
			Report.DuplicateLearnerStateCount += 1;
			continue;
		}

		SeenLearnerStateKeys.Add(LearnerStateKey);
	}

	if (Report.TotalRunRecordCount > 0)
	{
		TArray<FHyperTwistTrainingRunRecord> ValidRunRecords;
		TMap<FString, int32> RunRecordIndexBySessionId;
		for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
		{
			if (!RunRecord.IsStructurallyValid())
			{
				continue;
			}

			const FString& SessionId = RunRecord.Session.TrainingSessionId;
			if (const int32* ExistingIndex = RunRecordIndexBySessionId.Find(SessionId))
			{
				ValidRunRecords[*ExistingIndex] = RunRecord;
			}
			else
			{
				RunRecordIndexBySessionId.Add(SessionId, ValidRunRecords.Add(RunRecord));
			}
		}
		ValidRunRecords = HyperTwistTrainingRepositoryLibraryInternal::SortRunRecordsByUpdateUtc(
			ValidRunRecords
		);

		const TArray<FHyperTwistTrainingCaseLearnerState> ExpectedLearnerStates =
			HyperTwistTrainingRepositoryLibraryInternal::DeriveLearnerStatesFromRunRecords(ValidRunRecords);
		const TArray<FHyperTwistTrainingCaseLearnerState> ActualLearnerStates =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeLearnerStates(RepositoryState.LearnerStates);

		TMap<FString, FHyperTwistTrainingCaseLearnerState> ExpectedLearnerStateByKey;
		for (const FHyperTwistTrainingCaseLearnerState& LearnerState : ExpectedLearnerStates)
		{
			ExpectedLearnerStateByKey.Add(
				HyperTwistTrainingRepositoryLibraryInternal::MakeCaseKey(
					LearnerState.UserId,
					LearnerState.DeckId,
					LearnerState.CaseId
				),
				LearnerState
			);
		}

		TMap<FString, FHyperTwistTrainingCaseLearnerState> ActualLearnerStateByKey;
		for (const FHyperTwistTrainingCaseLearnerState& LearnerState : ActualLearnerStates)
		{
			ActualLearnerStateByKey.Add(
				HyperTwistTrainingRepositoryLibraryInternal::MakeCaseKey(
					LearnerState.UserId,
					LearnerState.DeckId,
					LearnerState.CaseId
				),
				LearnerState
			);
		}

		for (const TPair<FString, FHyperTwistTrainingCaseLearnerState>& Pair : ExpectedLearnerStateByKey)
		{
			const FHyperTwistTrainingCaseLearnerState* ActualLearnerState = ActualLearnerStateByKey.Find(Pair.Key);
			if (ActualLearnerState == nullptr
				|| !HyperTwistTrainingRepositoryLibraryInternal::DoSerializedStructsMatch(
					*ActualLearnerState,
					Pair.Value))
			{
				Report.OutOfSyncLearnerStateCount += 1;
			}
		}
		for (const TPair<FString, FHyperTwistTrainingCaseLearnerState>& Pair : ActualLearnerStateByKey)
		{
			if (!ExpectedLearnerStateByKey.Contains(Pair.Key))
			{
				Report.OutOfSyncLearnerStateCount += 1;
			}
		}
	}

	Report.TotalReviewPlanCount = RepositoryState.ReviewPlans.Num();
	TSet<FString> SeenReviewPlanIds;
	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : RepositoryState.ReviewPlans)
	{
		if (!ReviewPlan.IsStructurallyValid())
		{
			Report.InvalidReviewPlanCount += 1;
			continue;
		}
		if (SeenReviewPlanIds.Contains(ReviewPlan.PlanId))
		{
			Report.DuplicateReviewPlanCount += 1;
			continue;
		}

		SeenReviewPlanIds.Add(ReviewPlan.PlanId);
	}

	TArray<FHyperTwistTrainingReviewPlanState> ValidReviewPlans;
	TSet<FString> UniqueValidReviewPlanIds;
	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : RepositoryState.ReviewPlans)
	{
		if (!ReviewPlan.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingReviewPlanState NormalizedReviewPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(ReviewPlan);
		if (!NormalizedReviewPlan.IsStructurallyValid())
		{
			Report.InvalidReviewPlanCount += 1;
			continue;
		}
		if (UniqueValidReviewPlanIds.Contains(NormalizedReviewPlan.PlanId))
		{
			continue;
		}

		UniqueValidReviewPlanIds.Add(NormalizedReviewPlan.PlanId);
		if (!HyperTwistTrainingRepositoryLibraryInternal::DoSerializedStructsMatch(
				ReviewPlan,
				NormalizedReviewPlan))
		{
			Report.OutOfSyncReviewPlanCount += 1;
		}
		ValidReviewPlans.Add(NormalizedReviewPlan);
	}

	Report.TotalStoredSessionTemplateCount = RepositoryState.StoredSessionTemplates.Num();
	TSet<FString> SeenStoredTemplateKeys;
	for (const FHyperTwistTrainingSessionTemplate& SessionTemplate : RepositoryState.StoredSessionTemplates)
	{
		if (!SessionTemplate.IsStructurallyValid())
		{
			Report.InvalidStoredSessionTemplateCount += 1;
			continue;
		}

		const FString TemplateKey = HyperTwistTrainingRepositoryLibraryInternal::MakeTemplateKey(
			SessionTemplate.UserId,
			SessionTemplate.TemplateId
		);
		if (SeenStoredTemplateKeys.Contains(TemplateKey))
		{
			Report.DuplicateStoredSessionTemplateCount += 1;
			continue;
		}

		SeenStoredTemplateKeys.Add(TemplateKey);
	}

	Report.TotalMethodDrillFavoriteCount = RepositoryState.StoredMethodDrillFavorites.Num();
	TSet<FString> SeenMethodDrillFavoriteKeys;
	for (const FHyperTwistTrainingMethodDrillFavoriteEntry& FavoriteEntry : RepositoryState.StoredMethodDrillFavorites)
	{
		if (!FavoriteEntry.IsStructurallyValid())
		{
			Report.InvalidMethodDrillFavoriteCount += 1;
			continue;
		}

		const FString FavoriteKey = HyperTwistTrainingRepositoryLibraryInternal::MakeMethodDrillFavoriteKey(
			FavoriteEntry.UserId,
			FavoriteEntry.DrillId,
			FavoriteEntry.CaseId
		);
		if (SeenMethodDrillFavoriteKeys.Contains(FavoriteKey))
		{
			Report.DuplicateMethodDrillFavoriteCount += 1;
			continue;
		}

		SeenMethodDrillFavoriteKeys.Add(FavoriteKey);
	}

	Report.TotalMethodDrillBatchCount = RepositoryState.StoredMethodDrillBatches.Num();
	TSet<FString> SeenMethodDrillBatchKeys;
	for (const FHyperTwistTrainingMethodDrillBatch& DrillBatch : RepositoryState.StoredMethodDrillBatches)
	{
		if (!DrillBatch.IsStructurallyValid())
		{
			Report.InvalidMethodDrillBatchCount += 1;
			continue;
		}

		const FString BatchKey = HyperTwistTrainingRepositoryLibraryInternal::MakeMethodDrillBatchKey(
			DrillBatch.UserId,
			DrillBatch.BatchId
		);
		if (SeenMethodDrillBatchKeys.Contains(BatchKey))
		{
			Report.DuplicateMethodDrillBatchCount += 1;
			continue;
		}

		SeenMethodDrillBatchKeys.Add(BatchKey);
	}

	Report.TotalFriendLinkCount = RepositoryState.StoredFriendLinks.Num();
	TSet<FString> SeenFriendLinkKeys;
	for (const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord : RepositoryState.StoredFriendLinks)
	{
		const FHyperTwistTrainingFriendLinkRecord NormalizedFriendLinkRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(FriendLinkRecord);
		if (!NormalizedFriendLinkRecord.IsStructurallyValid())
		{
			Report.InvalidFriendLinkCount += 1;
			continue;
		}

		const FString FriendLinkKey = HyperTwistTrainingRepositoryLibraryInternal::MakeFriendLinkKey(
			NormalizedFriendLinkRecord.UserId,
			NormalizedFriendLinkRecord.FriendSnapshot.FriendUserId
		);
		if (SeenFriendLinkKeys.Contains(FriendLinkKey))
		{
			Report.DuplicateFriendLinkCount += 1;
			continue;
		}

		SeenFriendLinkKeys.Add(FriendLinkKey);
	}

	Report.TotalNotificationCount = RepositoryState.StoredNotifications.Num();
	TSet<FString> SeenNotificationIds;
	for (const FHyperTwistTrainingNotificationRecord& NotificationRecord : RepositoryState.StoredNotifications)
	{
		const FHyperTwistTrainingNotificationRecord NormalizedNotificationRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeNotificationRecord(NotificationRecord);
		if (!NormalizedNotificationRecord.IsStructurallyValid())
		{
			Report.InvalidNotificationCount += 1;
			continue;
		}

		if (SeenNotificationIds.Contains(NormalizedNotificationRecord.NotificationId))
		{
			Report.DuplicateNotificationCount += 1;
			continue;
		}

		SeenNotificationIds.Add(NormalizedNotificationRecord.NotificationId);
	}

	Report.TotalChallengeCount = RepositoryState.StoredChallenges.Num();
	TSet<FString> SeenChallengeIds;
	for (const FHyperTwistTrainingChallengeRecord& ChallengeRecord : RepositoryState.StoredChallenges)
	{
		const FHyperTwistTrainingChallengeRecord NormalizedChallengeRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeChallengeRecord(ChallengeRecord);
		if (!NormalizedChallengeRecord.IsStructurallyValid())
		{
			Report.InvalidChallengeCount += 1;
			continue;
		}

		if (SeenChallengeIds.Contains(NormalizedChallengeRecord.ChallengeId))
		{
			Report.DuplicateChallengeCount += 1;
			continue;
		}

		SeenChallengeIds.Add(NormalizedChallengeRecord.ChallengeId);
	}

	Report.TotalCoachActionPlanCount = RepositoryState.StoredCoachActionPlans.Num();
	TSet<FString> SeenCoachActionPlanKeys;
	for (const FHyperTwistTrainingCoachActionPlan& ActionPlan : RepositoryState.StoredCoachActionPlans)
	{
		if (!ActionPlan.IsStructurallyValid())
		{
			Report.InvalidCoachActionPlanCount += 1;
			continue;
		}

		const FString ActionPlanKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachActionPlanKey(
			ActionPlan.UserId,
			ActionPlan.PlanId
		);
		if (SeenCoachActionPlanKeys.Contains(ActionPlanKey))
		{
			Report.DuplicateCoachActionPlanCount += 1;
			continue;
		}

		SeenCoachActionPlanKeys.Add(ActionPlanKey);
	}

	Report.TotalCoachSessionQueueCount = RepositoryState.StoredCoachSessionQueues.Num();
	TSet<FString> SeenCoachSessionQueueKeys;
	for (const FHyperTwistTrainingCoachSessionQueueState& QueueState : RepositoryState.StoredCoachSessionQueues)
	{
		if (!QueueState.IsStructurallyValid())
		{
			Report.InvalidCoachSessionQueueCount += 1;
			continue;
		}

		const FString QueueKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueKey(
			QueueState.UserId,
			QueueState.QueueId
		);
		if (SeenCoachSessionQueueKeys.Contains(QueueKey))
		{
			Report.DuplicateCoachSessionQueueCount += 1;
			continue;
		}

		SeenCoachSessionQueueKeys.Add(QueueKey);
	}

	Report.TotalCoachSessionQueueHistoryCount = RepositoryState.StoredCoachSessionQueueHistory.Num();
	TSet<FString> SeenCoachSessionQueueHistoryIds;
	for (const FHyperTwistTrainingCoachSessionQueueHistoryEntry& HistoryEntry : RepositoryState.StoredCoachSessionQueueHistory)
	{
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry NormalizedHistoryEntry =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueHistoryEntry(HistoryEntry);
		if (!NormalizedHistoryEntry.IsStructurallyValid())
		{
			Report.InvalidCoachSessionQueueHistoryCount += 1;
			continue;
		}
		if (SeenCoachSessionQueueHistoryIds.Contains(NormalizedHistoryEntry.HistoryEntryId))
		{
			Report.DuplicateCoachSessionQueueHistoryCount += 1;
			continue;
		}
		if (!HyperTwistTrainingRepositoryLibraryInternal::DoSerializedStructsMatch(
				HistoryEntry,
				NormalizedHistoryEntry))
		{
			Report.OutOfSyncCoachSessionQueueHistoryCount += 1;
		}

		SeenCoachSessionQueueHistoryIds.Add(NormalizedHistoryEntry.HistoryEntryId);
	}

	TSet<FString> ValidRunSessionIds;
	TSet<FString> ValidAttemptIds;
	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (RunRecord.IsStructurallyValid())
		{
			ValidRunSessionIds.Add(RunRecord.Session.TrainingSessionId);
			for (const FHyperTwistTrainingAttempt& Attempt : RunRecord.Attempts)
			{
				if (Attempt.IsStructurallyValid())
				{
					ValidAttemptIds.Add(Attempt.AttemptId);
				}
			}
		}
	}

	TSet<FString> ValidReviewPlanIds;
	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : ValidReviewPlans)
	{
		if (ReviewPlan.IsStructurallyValid())
		{
			ValidReviewPlanIds.Add(ReviewPlan.PlanId);
		}
	}

	TArray<FHyperTwistTrainingCoachActionPlan> ValidCoachActionPlans;
	TMap<FString, int32> ValidCoachActionPlanIndexByKey;
	for (const FHyperTwistTrainingCoachActionPlan& ActionPlan : RepositoryState.StoredCoachActionPlans)
	{
		if (!ActionPlan.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
		if (!NormalizedPlan.IsStructurallyValid())
		{
			Report.InvalidCoachActionPlanCount += 1;
			continue;
		}

		const FString ActionPlanKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachActionPlanKey(
			NormalizedPlan.UserId,
			NormalizedPlan.PlanId
		);
		if (ValidCoachActionPlanIndexByKey.Contains(ActionPlanKey))
		{
			continue;
		}

		if (!HyperTwistTrainingRepositoryLibraryInternal::DoSerializedStructsMatch(
				ActionPlan,
				NormalizedPlan))
		{
			Report.OutOfSyncCoachActionPlanCount += 1;
		}
		ValidCoachActionPlanIndexByKey.Add(ActionPlanKey, ValidCoachActionPlans.Add(NormalizedPlan));
	}

	for (const FHyperTwistTrainingCoachActionPlan& ActionPlan : ValidCoachActionPlans)
	{
		if (!ActionPlan.SourceSessionId.IsEmpty()
			&& !ValidRunSessionIds.Contains(ActionPlan.SourceSessionId))
		{
			Report.MissingCoachActionPlanSourceSessionCount += 1;
		}
		if (!ActionPlan.SourceReviewPlanId.IsEmpty()
			&& !ValidReviewPlanIds.Contains(ActionPlan.SourceReviewPlanId))
		{
			Report.MissingCoachActionPlanSourceReviewPlanCount += 1;
		}

		const HyperTwistTrainingRepositoryLibraryInternal::FCoachActionPlanLineageAnalysis LineageAnalysis =
			HyperTwistTrainingRepositoryLibraryInternal::AnalyzeCoachActionPlanLineage(
				ActionPlan,
				ValidCoachActionPlans,
				ValidCoachActionPlanIndexByKey
			);
		if (LineageAnalysis.bMissingImmediateParent)
		{
			Report.OrphanedCoachActionPlanParentCount += 1;
		}
		if (LineageAnalysis.bRootMismatch || LineageAnalysis.bMissingHigherAncestor)
		{
			Report.OrphanedCoachActionPlanRootCount += 1;
		}
		if (LineageAnalysis.bDetectedCycle)
		{
			Report.CyclicCoachActionPlanLineageCount += 1;
		}
		if (LineageAnalysis.bDepthMismatch)
		{
			Report.BrokenCoachActionPlanDepthCount += 1;
		}
	}

	TArray<FHyperTwistTrainingCoachSessionQueueState> ValidCoachSessionQueues;
	TSet<FString> UniqueCoachSessionQueueKeys;
	for (const FHyperTwistTrainingCoachSessionQueueState& QueueState : RepositoryState.StoredCoachSessionQueues)
	{
		if (!QueueState.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingCoachSessionQueueState NormalizedQueueState =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
		if (!NormalizedQueueState.IsStructurallyValid())
		{
			Report.InvalidCoachSessionQueueCount += 1;
			continue;
		}

		const FString QueueKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueKey(
			NormalizedQueueState.UserId,
			NormalizedQueueState.QueueId
		);
		if (!UniqueCoachSessionQueueKeys.Contains(QueueKey))
		{
			UniqueCoachSessionQueueKeys.Add(QueueKey);
			if (!HyperTwistTrainingRepositoryLibraryInternal::DoSerializedStructsMatch(
					QueueState,
					NormalizedQueueState))
			{
				Report.OutOfSyncCoachSessionQueueCount += 1;
			}
			ValidCoachSessionQueues.Add(NormalizedQueueState);
		}
	}

	TMap<FString, TSet<FString>> ValidCoachSessionQueueEntryIdsByKey;
	for (const FHyperTwistTrainingCoachSessionQueueState& QueueState : ValidCoachSessionQueues)
	{
		const FString QueueKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueKey(
			QueueState.UserId,
			QueueState.QueueId
		);
		TSet<FString>& EntryIds = ValidCoachSessionQueueEntryIdsByKey.FindOrAdd(QueueKey);
		for (const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : QueueState.Entries)
		{
			if (!Entry.EntryId.IsEmpty())
			{
				EntryIds.Add(Entry.EntryId);
			}
		}
	}

	for (const FHyperTwistTrainingCoachSessionQueueState& QueueState : ValidCoachSessionQueues)
	{
		const FHyperTwistTrainingCoachSessionQueueStateEntry* ActiveEntry =
			!QueueState.ActiveEntryId.IsEmpty()
				? QueueState.Entries.FindByPredicate(
					[&QueueState](const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry)
					{
						return Entry.EntryId == QueueState.ActiveEntryId;
					}
				)
				: nullptr;
		if (!QueueState.ActiveEntryId.IsEmpty()
			&& (ActiveEntry == nullptr
				|| (ActiveEntry->EntryState != EHyperTwistTrainingCoachSessionQueueEntryState::Ready
					&& ActiveEntry->EntryState != EHyperTwistTrainingCoachSessionQueueEntryState::InProgress)))
		{
			Report.InvalidCoachSessionQueueActiveEntryCount += 1;
		}
		if (!QueueState.ActiveTrainingSessionId.IsEmpty()
			&& !ValidRunSessionIds.Contains(QueueState.ActiveTrainingSessionId))
		{
			Report.MissingCoachSessionQueueActiveSessionCount += 1;
		}

		for (const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : QueueState.Entries)
		{
			const bool bMissingRequiredInProgressSession =
				Entry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress
				&& Entry.SourceTrainingSessionId.IsEmpty();
			const bool bBrokenSessionReference =
				!Entry.SourceTrainingSessionId.IsEmpty()
				&& !ValidRunSessionIds.Contains(Entry.SourceTrainingSessionId);
			if (bMissingRequiredInProgressSession || bBrokenSessionReference)
			{
				Report.MissingCoachSessionQueueSourceSessionCount += 1;
			}
		}
	}

	for (const FHyperTwistTrainingCoachSessionQueueHistoryEntry& HistoryEntry : RepositoryState.StoredCoachSessionQueueHistory)
	{
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry NormalizedHistoryEntry =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueHistoryEntry(HistoryEntry);
		if (!NormalizedHistoryEntry.IsStructurallyValid())
		{
			continue;
		}

		const FString QueueKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueKey(
			NormalizedHistoryEntry.UserId,
			NormalizedHistoryEntry.QueueId
		);
		const TSet<FString>* ValidEntryIds = ValidCoachSessionQueueEntryIdsByKey.Find(QueueKey);
		if (ValidEntryIds == nullptr)
		{
			Report.MissingCoachSessionQueueHistoryQueueCount += 1;
			continue;
		}
		if (!ValidEntryIds->Contains(NormalizedHistoryEntry.EntryId))
		{
			Report.MissingCoachSessionQueueHistoryEntryCount += 1;
			continue;
		}
		if (!NormalizedHistoryEntry.SourceTrainingSessionId.IsEmpty()
			&& !ValidRunSessionIds.Contains(NormalizedHistoryEntry.SourceTrainingSessionId))
		{
			Report.MissingCoachSessionQueueHistorySourceSessionCount += 1;
		}
	}

	Report.TotalSmartDeviceSessionCount = RepositoryState.StoredSmartDeviceSessions.Num();
	TSet<FString> SeenSmartDeviceSessionIds;
	TMap<FString, FHyperTwistTrainingSmartDeviceSessionRecord> ValidSmartDeviceSessionsById;
	for (const FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord : RepositoryState.StoredSmartDeviceSessions)
	{
		const FHyperTwistTrainingSmartDeviceSessionRecord NormalizedSessionRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceSessionRecord(SessionRecord);
		if (!NormalizedSessionRecord.IsStructurallyValid())
		{
			Report.InvalidSmartDeviceSessionCount += 1;
			continue;
		}
		if (SeenSmartDeviceSessionIds.Contains(NormalizedSessionRecord.DeviceSessionId))
		{
			Report.DuplicateSmartDeviceSessionCount += 1;
			continue;
		}

		SeenSmartDeviceSessionIds.Add(NormalizedSessionRecord.DeviceSessionId);
		ValidSmartDeviceSessionsById.Add(NormalizedSessionRecord.DeviceSessionId, NormalizedSessionRecord);
		if (!ValidRunSessionIds.Contains(NormalizedSessionRecord.TrainingSessionId))
		{
			Report.MissingSmartDeviceSessionSourceSessionCount += 1;
		}
	}

	Report.TotalSmartDeviceEventFrameCount = RepositoryState.StoredSmartDeviceEventFrames.Num();
	TSet<FString> SeenSmartDeviceEventKeys;
	for (const FHyperTwistTrainingSmartDeviceEventFrame& EventFrame : RepositoryState.StoredSmartDeviceEventFrames)
	{
		const FHyperTwistTrainingSmartDeviceEventFrame NormalizedEventFrame =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceEventFrame(EventFrame);
		const FString EventKey =
			HyperTwistTrainingRepositoryLibraryInternal::BuildSmartDeviceEventKey(NormalizedEventFrame);
		if (!NormalizedEventFrame.IsStructurallyValid() || EventKey.IsEmpty())
		{
			Report.InvalidSmartDeviceEventFrameCount += 1;
			continue;
		}
		if (SeenSmartDeviceEventKeys.Contains(EventKey))
		{
			Report.DuplicateSmartDeviceEventFrameCount += 1;
			continue;
		}

		SeenSmartDeviceEventKeys.Add(EventKey);
		if (!ValidRunSessionIds.Contains(NormalizedEventFrame.TrainingSessionId))
		{
			Report.MissingSmartDeviceEventSourceSessionCount += 1;
		}
		if (!ValidSmartDeviceSessionsById.Contains(NormalizedEventFrame.DeviceSessionId))
		{
			Report.MissingSmartDeviceEventSessionRecordCount += 1;
		}
		if (!NormalizedEventFrame.LinkedAttemptId.IsEmpty()
			&& !ValidAttemptIds.Contains(NormalizedEventFrame.LinkedAttemptId))
		{
			Report.MissingSmartDeviceEventAttemptLinkCount += 1;
		}
	}

	if (Report.InvalidRunRecordCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-run-records")
		);
	}
	if (Report.DuplicateRunRecordCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("deduplicate-run-records-by-session-id")
		);
	}
	if (Report.TotalRunRecordCount > 0
		&& (Report.TotalLearnerStateCount == 0
			|| Report.InvalidLearnerStateCount > 0
			|| Report.DuplicateLearnerStateCount > 0
			|| Report.OutOfSyncLearnerStateCount > 0))
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("rebuild-learner-states-from-run-records")
		);
	}
	else if (Report.InvalidLearnerStateCount > 0
		|| Report.DuplicateLearnerStateCount > 0
		|| Report.OutOfSyncLearnerStateCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("filter-and-deduplicate-learner-states")
		);
	}
	if (Report.InvalidReviewPlanCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-review-plans")
		);
	}
	if (Report.DuplicateReviewPlanCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("deduplicate-review-plans-by-plan-id")
		);
	}
	if (Report.OutOfSyncReviewPlanCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-review-plans")
		);
	}
	if (Report.InvalidStoredSessionTemplateCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-stored-session-templates")
		);
	}
	if (Report.DuplicateStoredSessionTemplateCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-and-deduplicate-stored-session-templates")
		);
	}
	if (Report.InvalidMethodDrillFavoriteCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-method-drill-favorites")
		);
	}
	if (Report.DuplicateMethodDrillFavoriteCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-and-deduplicate-method-drill-favorites")
		);
	}
	if (Report.InvalidMethodDrillBatchCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-method-drill-batches")
		);
	}
	if (Report.DuplicateMethodDrillBatchCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-and-deduplicate-method-drill-batches")
		);
	}
	if (Report.InvalidCoachActionPlanCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-coach-action-plans")
		);
	}
	if (Report.DuplicateCoachActionPlanCount > 0 || Report.OutOfSyncCoachActionPlanCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-and-deduplicate-coach-action-plans")
		);
	}
	if (Report.MissingCoachActionPlanSourceSessionCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("clear-missing-coach-action-plan-source-session-links")
		);
	}
	if (Report.MissingCoachActionPlanSourceReviewPlanCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("clear-missing-coach-action-plan-source-review-links")
		);
	}
	if (Report.OrphanedCoachActionPlanParentCount > 0
		|| Report.OrphanedCoachActionPlanRootCount > 0
		|| Report.CyclicCoachActionPlanLineageCount > 0
		|| Report.BrokenCoachActionPlanDepthCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-coach-action-plan-lineage")
		);
	}
	if (Report.InvalidCoachSessionQueueCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-coach-session-queues")
		);
	}
	if (Report.DuplicateCoachSessionQueueCount > 0 || Report.OutOfSyncCoachSessionQueueCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-and-deduplicate-coach-session-queues")
		);
	}
	if (Report.MissingCoachSessionQueueSourceSessionCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("clear-missing-coach-session-queue-source-session-links")
		);
	}
	if (Report.InvalidCoachSessionQueueActiveEntryCount > 0
		|| Report.MissingCoachSessionQueueActiveSessionCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-coach-session-queue-active-links")
		);
	}
	if (Report.InvalidCoachSessionQueueHistoryCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-coach-session-queue-history")
		);
	}
	if (Report.DuplicateCoachSessionQueueHistoryCount > 0
		|| Report.OutOfSyncCoachSessionQueueHistoryCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("normalize-and-deduplicate-coach-session-queue-history")
		);
	}
	if (Report.MissingCoachSessionQueueHistorySourceSessionCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("clear-missing-coach-session-queue-history-session-links")
		);
	}
	if (Report.MissingCoachSessionQueueHistoryQueueCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-orphaned-coach-session-queue-history-queue-links")
		);
	}
	if (Report.MissingCoachSessionQueueHistoryEntryCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-orphaned-coach-session-queue-history-entry-links")
		);
	}
	if (Report.InvalidSmartDeviceSessionCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-smart-device-sessions")
		);
	}
	if (Report.DuplicateSmartDeviceSessionCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("deduplicate-smart-device-sessions-by-session-id")
		);
	}
	if (Report.MissingSmartDeviceSessionSourceSessionCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("clear-smart-device-session-links-to-missing-training-sessions")
		);
	}
	if (Report.InvalidSmartDeviceEventFrameCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("drop-invalid-smart-device-event-frames")
		);
	}
	if (Report.DuplicateSmartDeviceEventFrameCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("deduplicate-smart-device-event-frames-by-session-and-event-id")
		);
	}
	if (Report.MissingSmartDeviceEventSourceSessionCount > 0
		|| Report.MissingSmartDeviceEventSessionRecordCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("clear-smart-device-event-links-to-missing-sessions")
		);
	}
	if (Report.MissingSmartDeviceEventAttemptLinkCount > 0)
	{
		HyperTwistTrainingRepositoryLibraryInternal::AppendRepairAction(
			Report.RepairActions,
			TEXT("clear-smart-device-event-links-to-missing-attempts")
		);
	}

	return Report;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::RepairRepositoryState(
	const FHyperTwistTrainingRepositoryState& RepositoryState
)
{
	FHyperTwistTrainingRepositoryState RepairedState;

	TMap<FString, int32> RunRecordIndexBySessionId;
	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (!RunRecord.IsStructurallyValid())
		{
			continue;
		}

		const FString& SessionId = RunRecord.Session.TrainingSessionId;
		if (const int32* ExistingIndex = RunRecordIndexBySessionId.Find(SessionId))
		{
			RepairedState.RunRecords[*ExistingIndex] = RunRecord;
		}
		else
		{
			RunRecordIndexBySessionId.Add(SessionId, RepairedState.RunRecords.Add(RunRecord));
		}
	}
	RepairedState.RunRecords = HyperTwistTrainingRepositoryLibraryInternal::SortRunRecordsByUpdateUtc(
		RepairedState.RunRecords
	);

	if (RepairedState.RunRecords.Num() > 0)
	{
		RepairedState.LearnerStates = HyperTwistTrainingRepositoryLibraryInternal::DeriveLearnerStatesFromRunRecords(
			RepairedState.RunRecords
		);
	}
	else
	{
		RepairedState.LearnerStates = HyperTwistTrainingRepositoryLibraryInternal::NormalizeLearnerStates(
			RepositoryState.LearnerStates
		);
	}

	TMap<FString, int32> ReviewPlanIndexById;
	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : RepositoryState.ReviewPlans)
	{
		if (!ReviewPlan.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingReviewPlanState NormalizedReviewPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(ReviewPlan);
		if (!NormalizedReviewPlan.IsStructurallyValid())
		{
			continue;
		}

		if (const int32* ExistingIndex = ReviewPlanIndexById.Find(NormalizedReviewPlan.PlanId))
		{
			RepairedState.ReviewPlans[*ExistingIndex] = NormalizedReviewPlan;
		}
		else
		{
			ReviewPlanIndexById.Add(
				NormalizedReviewPlan.PlanId,
				RepairedState.ReviewPlans.Add(NormalizedReviewPlan)
			);
		}
	}

	RepairedState.ReviewPlans.Sort([](
		const FHyperTwistTrainingReviewPlanState& Left,
		const FHyperTwistTrainingReviewPlanState& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}

		const FString LeftSortUtc = !Left.CreatedAtUtc.IsEmpty() ? Left.CreatedAtUtc : Left.ReferenceUtc;
		const FString RightSortUtc = !Right.CreatedAtUtc.IsEmpty() ? Right.CreatedAtUtc : Right.ReferenceUtc;
		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			LeftSortUtc,
			RightSortUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.PlanId < Right.PlanId;
	});

	TMap<FString, int32> StoredTemplateIndexByKey;
	for (const FHyperTwistTrainingSessionTemplate& SessionTemplate : RepositoryState.StoredSessionTemplates)
	{
		if (!SessionTemplate.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingSessionTemplate NormalizedTemplate =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeStoredTemplate(SessionTemplate);
		if (!NormalizedTemplate.IsStructurallyValid())
		{
			continue;
		}

		const FString TemplateKey = HyperTwistTrainingRepositoryLibraryInternal::MakeTemplateKey(
			NormalizedTemplate.UserId,
			NormalizedTemplate.TemplateId
		);
		if (const int32* ExistingIndex = StoredTemplateIndexByKey.Find(TemplateKey))
		{
			RepairedState.StoredSessionTemplates[*ExistingIndex] = NormalizedTemplate;
		}
		else
		{
			StoredTemplateIndexByKey.Add(
				TemplateKey,
				RepairedState.StoredSessionTemplates.Add(NormalizedTemplate)
			);
		}
	}

	RepairedState.StoredSessionTemplates.Sort([](
		const FHyperTwistTrainingSessionTemplate& Left,
		const FHyperTwistTrainingSessionTemplate& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}
		if (Left.bUserCreated != Right.bUserCreated)
		{
			return Left.bUserCreated && !Right.bUserCreated;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastUpdatedAtUtc,
			Right.LastUpdatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.TemplateId < Right.TemplateId;
	});

	TMap<FString, int32> MethodDrillFavoriteIndexByKey;
	for (const FHyperTwistTrainingMethodDrillFavoriteEntry& FavoriteEntry : RepositoryState.StoredMethodDrillFavorites)
	{
		if (!FavoriteEntry.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingMethodDrillFavoriteEntry NormalizedFavorite =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeMethodDrillFavoriteEntry(FavoriteEntry);
		if (!NormalizedFavorite.IsStructurallyValid())
		{
			continue;
		}

		const FString FavoriteKey = HyperTwistTrainingRepositoryLibraryInternal::MakeMethodDrillFavoriteKey(
			NormalizedFavorite.UserId,
			NormalizedFavorite.DrillId,
			NormalizedFavorite.CaseId
		);
		if (const int32* ExistingIndex = MethodDrillFavoriteIndexByKey.Find(FavoriteKey))
		{
			RepairedState.StoredMethodDrillFavorites[*ExistingIndex] = NormalizedFavorite;
		}
		else
		{
			MethodDrillFavoriteIndexByKey.Add(
				FavoriteKey,
				RepairedState.StoredMethodDrillFavorites.Add(NormalizedFavorite)
			);
		}
	}

	RepairedState.StoredMethodDrillFavorites.Sort([](
		const FHyperTwistTrainingMethodDrillFavoriteEntry& Left,
		const FHyperTwistTrainingMethodDrillFavoriteEntry& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.AddedAtUtc,
			Right.AddedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		if (Left.DrillId != Right.DrillId)
		{
			return Left.DrillId < Right.DrillId;
		}

		return Left.CaseId < Right.CaseId;
	});

	TMap<FString, int32> MethodDrillBatchIndexByKey;
	for (const FHyperTwistTrainingMethodDrillBatch& DrillBatch : RepositoryState.StoredMethodDrillBatches)
	{
		if (!DrillBatch.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingMethodDrillBatch NormalizedBatch =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeMethodDrillBatch(DrillBatch);
		if (!NormalizedBatch.IsStructurallyValid())
		{
			continue;
		}

		const FString BatchKey = HyperTwistTrainingRepositoryLibraryInternal::MakeMethodDrillBatchKey(
			NormalizedBatch.UserId,
			NormalizedBatch.BatchId
		);
		if (const int32* ExistingIndex = MethodDrillBatchIndexByKey.Find(BatchKey))
		{
			RepairedState.StoredMethodDrillBatches[*ExistingIndex] = NormalizedBatch;
		}
		else
		{
			MethodDrillBatchIndexByKey.Add(
				BatchKey,
				RepairedState.StoredMethodDrillBatches.Add(NormalizedBatch)
			);
		}
	}

	RepairedState.StoredMethodDrillBatches.Sort([](
		const FHyperTwistTrainingMethodDrillBatch& Left,
		const FHyperTwistTrainingMethodDrillBatch& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastUpdatedAtUtc,
			Right.LastUpdatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.BatchId < Right.BatchId;
	});

	TMap<FString, int32> FriendLinkIndexByKey;
	for (const FHyperTwistTrainingFriendLinkRecord& FriendLinkRecord : RepositoryState.StoredFriendLinks)
	{
		const FHyperTwistTrainingFriendLinkRecord NormalizedFriendLinkRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeFriendLinkRecord(FriendLinkRecord);
		if (!NormalizedFriendLinkRecord.IsStructurallyValid())
		{
			continue;
		}

		const FString FriendLinkKey = HyperTwistTrainingRepositoryLibraryInternal::MakeFriendLinkKey(
			NormalizedFriendLinkRecord.UserId,
			NormalizedFriendLinkRecord.FriendSnapshot.FriendUserId
		);
		if (const int32* ExistingIndex = FriendLinkIndexByKey.Find(FriendLinkKey))
		{
			RepairedState.StoredFriendLinks[*ExistingIndex] = NormalizedFriendLinkRecord;
		}
		else
		{
			FriendLinkIndexByKey.Add(
				FriendLinkKey,
				RepairedState.StoredFriendLinks.Add(NormalizedFriendLinkRecord)
			);
		}
	}
	RepairedState.StoredFriendLinks = HyperTwistTrainingRepositoryLibraryInternal::SortFriendLinksByUpdateUtc(
		RepairedState.StoredFriendLinks
	);

	TMap<FString, int32> NotificationIndexById;
	for (const FHyperTwistTrainingNotificationRecord& NotificationRecord : RepositoryState.StoredNotifications)
	{
		const FHyperTwistTrainingNotificationRecord NormalizedNotificationRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeNotificationRecord(NotificationRecord);
		if (!NormalizedNotificationRecord.IsStructurallyValid())
		{
			continue;
		}

		if (const int32* ExistingIndex = NotificationIndexById.Find(NormalizedNotificationRecord.NotificationId))
		{
			RepairedState.StoredNotifications[*ExistingIndex] = NormalizedNotificationRecord;
		}
		else
		{
			NotificationIndexById.Add(
				NormalizedNotificationRecord.NotificationId,
				RepairedState.StoredNotifications.Add(NormalizedNotificationRecord)
			);
		}
	}
	RepairedState.StoredNotifications =
		HyperTwistTrainingRepositoryLibraryInternal::SortNotificationsByChangeUtc(
			RepairedState.StoredNotifications
		);

	TMap<FString, int32> ChallengeIndexById;
	for (const FHyperTwistTrainingChallengeRecord& ChallengeRecord : RepositoryState.StoredChallenges)
	{
		const FHyperTwistTrainingChallengeRecord NormalizedChallengeRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeChallengeRecord(ChallengeRecord);
		if (!NormalizedChallengeRecord.IsStructurallyValid())
		{
			continue;
		}

		if (const int32* ExistingIndex = ChallengeIndexById.Find(NormalizedChallengeRecord.ChallengeId))
		{
			RepairedState.StoredChallenges[*ExistingIndex] = NormalizedChallengeRecord;
		}
		else
		{
			ChallengeIndexById.Add(
				NormalizedChallengeRecord.ChallengeId,
				RepairedState.StoredChallenges.Add(NormalizedChallengeRecord)
			);
		}
	}
	RepairedState.StoredChallenges = HyperTwistTrainingRepositoryLibraryInternal::SortChallengesByUpdateUtc(
		RepairedState.StoredChallenges
	);

	TMap<FString, int32> CoachActionPlanIndexByKey;
	for (const FHyperTwistTrainingCoachActionPlan& ActionPlan : RepositoryState.StoredCoachActionPlans)
	{
		if (!ActionPlan.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
		if (!NormalizedPlan.IsStructurallyValid())
		{
			continue;
		}

		const FString ActionPlanKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachActionPlanKey(
			NormalizedPlan.UserId,
			NormalizedPlan.PlanId
		);
		if (const int32* ExistingIndex = CoachActionPlanIndexByKey.Find(ActionPlanKey))
		{
			RepairedState.StoredCoachActionPlans[*ExistingIndex] = NormalizedPlan;
		}
		else
		{
			CoachActionPlanIndexByKey.Add(
				ActionPlanKey,
				RepairedState.StoredCoachActionPlans.Add(NormalizedPlan)
			);
		}
	}

	RepairedState.StoredCoachActionPlans.Sort([](
		const FHyperTwistTrainingCoachActionPlan& Left,
		const FHyperTwistTrainingCoachActionPlan& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.CreatedAtUtc,
			Right.CreatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.PlanId < Right.PlanId;
	});

	TMap<FString, int32> CoachSessionQueueIndexByKey;
	for (const FHyperTwistTrainingCoachSessionQueueState& QueueState : RepositoryState.StoredCoachSessionQueues)
	{
		if (!QueueState.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingCoachSessionQueueState NormalizedQueueState =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
		if (!NormalizedQueueState.IsStructurallyValid())
		{
			continue;
		}

		const FString QueueKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueKey(
			NormalizedQueueState.UserId,
			NormalizedQueueState.QueueId
		);
		if (const int32* ExistingIndex = CoachSessionQueueIndexByKey.Find(QueueKey))
		{
			RepairedState.StoredCoachSessionQueues[*ExistingIndex] = NormalizedQueueState;
		}
		else
		{
			CoachSessionQueueIndexByKey.Add(
				QueueKey,
				RepairedState.StoredCoachSessionQueues.Add(NormalizedQueueState)
			);
		}
	}

	RepairedState.StoredCoachSessionQueues.Sort([](
		const FHyperTwistTrainingCoachSessionQueueState& Left,
		const FHyperTwistTrainingCoachSessionQueueState& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastUpdatedAtUtc,
			Right.LastUpdatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.QueueId < Right.QueueId;
	});

	TMap<FString, int32> CoachSessionQueueHistoryIndexById;
	for (const FHyperTwistTrainingCoachSessionQueueHistoryEntry& HistoryEntry : RepositoryState.StoredCoachSessionQueueHistory)
	{
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry NormalizedHistoryEntry =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueHistoryEntry(HistoryEntry);
		if (!NormalizedHistoryEntry.IsStructurallyValid())
		{
			continue;
		}

		if (const int32* ExistingIndex = CoachSessionQueueHistoryIndexById.Find(NormalizedHistoryEntry.HistoryEntryId))
		{
			RepairedState.StoredCoachSessionQueueHistory[*ExistingIndex] = NormalizedHistoryEntry;
		}
		else
		{
			CoachSessionQueueHistoryIndexById.Add(
				NormalizedHistoryEntry.HistoryEntryId,
				RepairedState.StoredCoachSessionQueueHistory.Add(NormalizedHistoryEntry)
			);
		}
	}

	RepairedState.StoredCoachSessionQueueHistory.Sort([](
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Left,
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}
		if (Left.QueueId != Right.QueueId)
		{
			return Left.QueueId < Right.QueueId;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.EventAtUtc,
			Right.EventAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare < 0;
		}

		return Left.HistoryEntryId < Right.HistoryEntryId;
	});

	TMap<FString, int32> SmartDeviceSessionIndexById;
	for (const FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord : RepositoryState.StoredSmartDeviceSessions)
	{
		const FHyperTwistTrainingSmartDeviceSessionRecord NormalizedSessionRecord =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceSessionRecord(SessionRecord);
		if (!NormalizedSessionRecord.IsStructurallyValid())
		{
			continue;
		}

		if (const int32* ExistingIndex = SmartDeviceSessionIndexById.Find(NormalizedSessionRecord.DeviceSessionId))
		{
			RepairedState.StoredSmartDeviceSessions[*ExistingIndex] = NormalizedSessionRecord;
		}
		else
		{
			SmartDeviceSessionIndexById.Add(
				NormalizedSessionRecord.DeviceSessionId,
				RepairedState.StoredSmartDeviceSessions.Add(NormalizedSessionRecord)
			);
		}
	}
	RepairedState.StoredSmartDeviceSessions =
		HyperTwistTrainingRepositoryLibraryInternal::SortSmartDeviceSessionsByUpdateUtc(
			RepairedState.StoredSmartDeviceSessions
		);

	TMap<FString, int32> SmartDeviceEventIndexByKey;
	for (const FHyperTwistTrainingSmartDeviceEventFrame& EventFrame : RepositoryState.StoredSmartDeviceEventFrames)
	{
		const FHyperTwistTrainingSmartDeviceEventFrame NormalizedEventFrame =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeSmartDeviceEventFrame(EventFrame);
		const FString EventKey =
			HyperTwistTrainingRepositoryLibraryInternal::BuildSmartDeviceEventKey(NormalizedEventFrame);
		if (!NormalizedEventFrame.IsStructurallyValid() || EventKey.IsEmpty())
		{
			continue;
		}

		if (const int32* ExistingIndex = SmartDeviceEventIndexByKey.Find(EventKey))
		{
			RepairedState.StoredSmartDeviceEventFrames[*ExistingIndex] = NormalizedEventFrame;
		}
		else
		{
			SmartDeviceEventIndexByKey.Add(
				EventKey,
				RepairedState.StoredSmartDeviceEventFrames.Add(NormalizedEventFrame)
			);
		}
	}
	RepairedState.StoredSmartDeviceEventFrames =
		HyperTwistTrainingRepositoryLibraryInternal::SortSmartDeviceEventFramesByOccurredAtUtc(
			RepairedState.StoredSmartDeviceEventFrames
		);
	HyperTwistTrainingRepositoryLibraryInternal::SyncSmartDeviceSessionsFromEvents(
		RepairedState.StoredSmartDeviceSessions,
		RepairedState.StoredSmartDeviceEventFrames
	);

	TSet<FString> ValidRunSessionIds;
	TSet<FString> ValidAttemptIds;
	for (const FHyperTwistTrainingRunRecord& RunRecord : RepairedState.RunRecords)
	{
		if (RunRecord.IsStructurallyValid())
		{
			ValidRunSessionIds.Add(RunRecord.Session.TrainingSessionId);
			for (const FHyperTwistTrainingAttempt& Attempt : RunRecord.Attempts)
			{
				if (Attempt.IsStructurallyValid())
				{
					ValidAttemptIds.Add(Attempt.AttemptId);
				}
			}
		}
	}

	TSet<FString> ValidReviewPlanIds;
	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : RepairedState.ReviewPlans)
	{
		if (ReviewPlan.IsStructurallyValid())
		{
			ValidReviewPlanIds.Add(ReviewPlan.PlanId);
		}
	}

	for (FHyperTwistTrainingCoachActionPlan& ActionPlan : RepairedState.StoredCoachActionPlans)
	{
		if (!ActionPlan.SourceSessionId.IsEmpty() && !ValidRunSessionIds.Contains(ActionPlan.SourceSessionId))
		{
			ActionPlan.SourceSessionId.Reset();
		}
		if (!ActionPlan.SourceReviewPlanId.IsEmpty()
			&& !ValidReviewPlanIds.Contains(ActionPlan.SourceReviewPlanId))
		{
			ActionPlan.SourceReviewPlanId.Reset();
		}
	}

	for (int32 PassIndex = 0; PassIndex < 2; ++PassIndex)
	{
		TMap<FString, int32> LineageCoachActionPlanIndexByKey;
		for (int32 PlanIndex = 0; PlanIndex < RepairedState.StoredCoachActionPlans.Num(); ++PlanIndex)
		{
			const FHyperTwistTrainingCoachActionPlan& ActionPlan = RepairedState.StoredCoachActionPlans[PlanIndex];
			LineageCoachActionPlanIndexByKey.Add(
				HyperTwistTrainingRepositoryLibraryInternal::MakeCoachActionPlanKey(
					ActionPlan.UserId,
					ActionPlan.PlanId
				),
				PlanIndex
			);
		}

		for (FHyperTwistTrainingCoachActionPlan& ActionPlan : RepairedState.StoredCoachActionPlans)
		{
			const HyperTwistTrainingRepositoryLibraryInternal::FCoachActionPlanLineageAnalysis LineageAnalysis =
				HyperTwistTrainingRepositoryLibraryInternal::AnalyzeCoachActionPlanLineage(
					ActionPlan,
					RepairedState.StoredCoachActionPlans,
					LineageCoachActionPlanIndexByKey
				);
			if (LineageAnalysis.bMissingImmediateParent || LineageAnalysis.bDetectedCycle)
			{
				ActionPlan.ParentPlanId.Reset();
				ActionPlan.RootPlanId = ActionPlan.PlanId;
				ActionPlan.FollowUpDepth = 0;
			}
			else
			{
				ActionPlan.RootPlanId = !LineageAnalysis.ActualRootPlanId.IsEmpty()
					? LineageAnalysis.ActualRootPlanId
					: ActionPlan.PlanId;
				ActionPlan.FollowUpDepth = FMath::Max(0, LineageAnalysis.ActualDepth);
			}

			ActionPlan = HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
		}
	}

	for (FHyperTwistTrainingCoachSessionQueueState& QueueState : RepairedState.StoredCoachSessionQueues)
	{
		for (FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : QueueState.Entries)
		{
			const bool bMissingSourceTrainingSession =
				!Entry.SourceTrainingSessionId.IsEmpty()
				&& !ValidRunSessionIds.Contains(Entry.SourceTrainingSessionId);
			const bool bBrokenInProgressSession =
				Entry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress
				&& (Entry.SourceTrainingSessionId.IsEmpty() || bMissingSourceTrainingSession);
			if (bMissingSourceTrainingSession)
			{
				Entry.SourceTrainingSessionId.Reset();
			}
			if (bBrokenInProgressSession)
			{
				Entry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
				Entry.StartedAtUtc.Reset();
				Entry.bCanStartImmediately = false;
			}
		}

		QueueState = HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
	}

	TMap<FString, TSet<FString>> ValidCoachSessionQueueEntryIdsByKey;
	for (const FHyperTwistTrainingCoachSessionQueueState& QueueState : RepairedState.StoredCoachSessionQueues)
	{
		const FString QueueKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueKey(
			QueueState.UserId,
			QueueState.QueueId
		);
		TSet<FString>& EntryIds = ValidCoachSessionQueueEntryIdsByKey.FindOrAdd(QueueKey);
		for (const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : QueueState.Entries)
		{
			if (!Entry.EntryId.IsEmpty())
			{
				EntryIds.Add(Entry.EntryId);
			}
		}
	}

	TArray<FHyperTwistTrainingCoachSessionQueueHistoryEntry> FilteredCoachSessionQueueHistory;
	for (FHyperTwistTrainingCoachSessionQueueHistoryEntry& HistoryEntry : RepairedState.StoredCoachSessionQueueHistory)
	{
		const FString QueueKey = HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueKey(
			HistoryEntry.UserId,
			HistoryEntry.QueueId
		);
		const TSet<FString>* ValidEntryIds = ValidCoachSessionQueueEntryIdsByKey.Find(QueueKey);
		if (ValidEntryIds == nullptr || !ValidEntryIds->Contains(HistoryEntry.EntryId))
		{
			continue;
		}

		if (!HistoryEntry.SourceTrainingSessionId.IsEmpty()
			&& !ValidRunSessionIds.Contains(HistoryEntry.SourceTrainingSessionId))
		{
			HistoryEntry.SourceTrainingSessionId.Reset();
		}

		HistoryEntry =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueHistoryEntry(HistoryEntry);
		if (HistoryEntry.IsStructurallyValid())
		{
			FilteredCoachSessionQueueHistory.Add(HistoryEntry);
		}
	}

	FilteredCoachSessionQueueHistory.Sort([](
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Left,
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Right
	)
	{
		if (Left.UserId != Right.UserId)
		{
			return Left.UserId < Right.UserId;
		}
		if (Left.QueueId != Right.QueueId)
		{
			return Left.QueueId < Right.QueueId;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.EventAtUtc,
			Right.EventAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare < 0;
		}

		return Left.HistoryEntryId < Right.HistoryEntryId;
	});
	RepairedState.StoredCoachSessionQueueHistory = MoveTemp(FilteredCoachSessionQueueHistory);

	TArray<FHyperTwistTrainingSmartDeviceSessionRecord> FilteredSmartDeviceSessions;
	FilteredSmartDeviceSessions.Reserve(RepairedState.StoredSmartDeviceSessions.Num());
	for (FHyperTwistTrainingSmartDeviceSessionRecord SessionRecord : RepairedState.StoredSmartDeviceSessions)
	{
		if (!ValidRunSessionIds.Contains(SessionRecord.TrainingSessionId))
		{
			continue;
		}

		TArray<FString> FilteredLinkedAttemptIds;
		for (const FString& AttemptId : SessionRecord.LinkedAttemptIds)
		{
			if (!AttemptId.IsEmpty() && ValidAttemptIds.Contains(AttemptId))
			{
				FilteredLinkedAttemptIds.AddUnique(AttemptId);
			}
		}

		FilteredLinkedAttemptIds.Sort();
		SessionRecord.LinkedAttemptIds = MoveTemp(FilteredLinkedAttemptIds);
		if (!SessionRecord.LastLinkedAttemptId.IsEmpty()
			&& !ValidAttemptIds.Contains(SessionRecord.LastLinkedAttemptId))
		{
			SessionRecord.LastLinkedAttemptId.Reset();
		}
		SessionRecord.LinkedAttemptCount = SessionRecord.LinkedAttemptIds.Num();
		if (SessionRecord.IsStructurallyValid())
		{
			FilteredSmartDeviceSessions.Add(SessionRecord);
		}
	}
	FilteredSmartDeviceSessions =
		HyperTwistTrainingRepositoryLibraryInternal::SortSmartDeviceSessionsByUpdateUtc(
			FilteredSmartDeviceSessions
		);
	RepairedState.StoredSmartDeviceSessions = MoveTemp(FilteredSmartDeviceSessions);

	TSet<FString> ValidSmartDeviceSessionIds;
	for (const FHyperTwistTrainingSmartDeviceSessionRecord& SessionRecord : RepairedState.StoredSmartDeviceSessions)
	{
		ValidSmartDeviceSessionIds.Add(SessionRecord.DeviceSessionId);
	}

	TArray<FHyperTwistTrainingSmartDeviceEventFrame> FilteredSmartDeviceEventFrames;
	FilteredSmartDeviceEventFrames.Reserve(RepairedState.StoredSmartDeviceEventFrames.Num());
	for (FHyperTwistTrainingSmartDeviceEventFrame EventFrame : RepairedState.StoredSmartDeviceEventFrames)
	{
		if (!ValidRunSessionIds.Contains(EventFrame.TrainingSessionId)
			|| !ValidSmartDeviceSessionIds.Contains(EventFrame.DeviceSessionId))
		{
			continue;
		}

		if (!EventFrame.LinkedAttemptId.IsEmpty() && !ValidAttemptIds.Contains(EventFrame.LinkedAttemptId))
		{
			EventFrame.LinkedAttemptId.Reset();
		}

		if (EventFrame.IsStructurallyValid())
		{
			FilteredSmartDeviceEventFrames.Add(EventFrame);
		}
	}
	FilteredSmartDeviceEventFrames =
		HyperTwistTrainingRepositoryLibraryInternal::SortSmartDeviceEventFramesByOccurredAtUtc(
			FilteredSmartDeviceEventFrames
		);
	RepairedState.StoredSmartDeviceEventFrames = MoveTemp(FilteredSmartDeviceEventFrames);
	HyperTwistTrainingRepositoryLibraryInternal::SyncSmartDeviceSessionsFromEvents(
		RepairedState.StoredSmartDeviceSessions,
		RepairedState.StoredSmartDeviceEventFrames
	);

	return RepairedState;
}

FHyperTwistTrainingCaseScopedStats UHyperTwistTrainingRepositoryLibrary::DeriveCaseScopedStats(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& CaseId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCaseScopedStats Stats;
	if (UserId.IsEmpty() || DeckId.IsEmpty() || CaseId.IsEmpty())
	{
		return Stats;
	}

	Stats.UserId = UserId;
	Stats.DeckId = DeckId;
	Stats.CaseId = CaseId;
	Stats.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	HyperTwistTrainingRepositoryLibraryInternal::FScopedStatsAccumulator Accumulator;
	const TArray<FHyperTwistTrainingRunRecord> Records = ListRunRecordsForDeck(RepositoryState, UserId, DeckId);
	for (const FHyperTwistTrainingRunRecord& RunRecord : Records)
	{
		for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptEntry : RunRecord.AttemptHistory)
		{
			if (AttemptEntry.CaseId != CaseId)
			{
				continue;
			}

			Accumulator.AddAttempt(AttemptEntry);
		}
	}

	Stats.AttemptCount = Accumulator.AttemptCount;
	Stats.SolveCount = Accumulator.SolveCount;
	Stats.SuccessCount = Accumulator.SuccessCount;
	Stats.FailureCount = Accumulator.FailureCount;
	Stats.TimeoutCount = Accumulator.TimeoutCount;
	Stats.DNFCount = Accumulator.DNFCount;
	Stats.AbortedCount = Accumulator.AbortedCount;
	Stats.MistakeAttemptCount = Accumulator.MistakeAttemptCount;
	Stats.SmartDeviceAttemptCount = Accumulator.SmartDeviceAttemptCount;
	Stats.SmartDeviceSolveCount = Accumulator.SmartDeviceSolveCount;
	Stats.RecognitionAttemptCount = Accumulator.RecognitionAttemptCount;
	Stats.RecognitionSolveCount = Accumulator.RecognitionSolveCount;
	Stats.BestExecutionTimeMs = Accumulator.BestExecutionTimeMs;
	Stats.BestRecognitionTimeMs = Accumulator.BestRecognitionTimeMs;
	Stats.BestTotalTimeMs = Accumulator.BestTotalTimeMs;
	Stats.BestRawSolveTimeMs = Accumulator.BestRawSolveTimeMs;
	Stats.AverageExecutionTimeMs = Accumulator.ExecutionSampleCount > 0
		? static_cast<int32>(Accumulator.ExecutionTimeAccumulator / Accumulator.ExecutionSampleCount)
		: 0;
	Stats.AverageRecognitionTimeMs = Accumulator.RecognitionSampleCount > 0
		? static_cast<int32>(Accumulator.RecognitionTimeAccumulator / Accumulator.RecognitionSampleCount)
		: 0;
	Stats.AverageTotalTimeMs = Accumulator.TotalSampleCount > 0
		? static_cast<int32>(Accumulator.TotalTimeAccumulator / Accumulator.TotalSampleCount)
		: 0;
	Stats.AverageRawSolveTimeMs = Accumulator.RawSolveSampleCount > 0
		? static_cast<int32>(Accumulator.RawSolveTimeAccumulator / Accumulator.RawSolveSampleCount)
		: 0;
	Stats.AverageInspectionTimeMs = Accumulator.InspectionSampleCount > 0
		? static_cast<int32>(Accumulator.InspectionTimeAccumulator / Accumulator.InspectionSampleCount)
		: 0;
	Stats.Plus2PenaltyCount = Accumulator.Plus2PenaltyCount;
	Stats.PrimaryDeliveryMode = Accumulator.ResolvePrimaryDeliveryMode();
	Stats.LastAttemptAtUtc = Accumulator.LastAttemptAtUtc;
	Stats.LastSuccessAtUtc = Accumulator.LastSuccessAtUtc;

	return Stats;
}

TArray<FHyperTwistTrainingCaseScopedStats> UHyperTwistTrainingRepositoryLibrary::ListCaseScopedStatsForDeck(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& ReferenceUtc
)
{
	TArray<FHyperTwistTrainingCaseScopedStats> ScopedStats;
	if (UserId.IsEmpty() || DeckId.IsEmpty())
	{
		return ScopedStats;
	}

	TSet<FString> CaseIds;
	const TArray<FHyperTwistTrainingRunRecord> Records = ListRunRecordsForDeck(RepositoryState, UserId, DeckId);
	for (const FHyperTwistTrainingRunRecord& RunRecord : Records)
	{
		for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptEntry : RunRecord.AttemptHistory)
		{
			if (!AttemptEntry.CaseId.IsEmpty())
			{
				CaseIds.Add(AttemptEntry.CaseId);
			}
		}
	}

	for (const FString& CaseId : CaseIds)
	{
		FHyperTwistTrainingCaseScopedStats Stats = DeriveCaseScopedStats(
			RepositoryState,
			UserId,
			DeckId,
			CaseId,
			ReferenceUtc
		);
		if (Stats.IsStructurallyValid())
		{
			ScopedStats.Add(Stats);
		}
	}

	ScopedStats.Sort([](const FHyperTwistTrainingCaseScopedStats& Left, const FHyperTwistTrainingCaseScopedStats& Right)
	{
		return Left.CaseId < Right.CaseId;
	});

	return ScopedStats;
}

FHyperTwistTrainingDeckScopedStats UHyperTwistTrainingRepositoryLibrary::DeriveDeckScopedStats(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingDeckScopedStats Stats;
	if (UserId.IsEmpty() || DeckId.IsEmpty())
	{
		return Stats;
	}

	Stats.UserId = UserId;
	Stats.DeckId = DeckId;
	Stats.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	HyperTwistTrainingRepositoryLibraryInternal::FScopedStatsAccumulator Accumulator;
	TSet<FString> TrackedCaseIds;
	int64 CompletedRunWallAccumulator = 0;
	int32 CompletedRunWallSamples = 0;

	const TArray<FHyperTwistTrainingRunRecord> Records = ListRunRecordsForDeck(RepositoryState, UserId, DeckId);
	for (const FHyperTwistTrainingRunRecord& RunRecord : Records)
	{
		Stats.SessionCount += 1;
		if (RunRecord.bCompleted)
		{
			Stats.CompletedRunCount += 1;
			const FString CompletedReferenceUtc = !RunRecord.Session.EndedAtUtc.IsEmpty()
				? RunRecord.Session.EndedAtUtc
				: RunRecord.LastUpdatedAtUtc;
			const int32 CompletedRunWallMs = HyperTwistTrainingRepositoryLibraryInternal::ComputeElapsedMilliseconds(
				RunRecord.Session.StartedAtUtc,
				CompletedReferenceUtc
			);
			if (CompletedRunWallMs > 0)
			{
				CompletedRunWallAccumulator += CompletedRunWallMs;
				CompletedRunWallSamples += 1;
				if (Stats.BestCompletedRunWallTimeMs == 0 || CompletedRunWallMs < Stats.BestCompletedRunWallTimeMs)
				{
					Stats.BestCompletedRunWallTimeMs = CompletedRunWallMs;
				}
			}

			if (Stats.LastCompletedRunAtUtc.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(CompletedReferenceUtc, Stats.LastCompletedRunAtUtc) > 0)
			{
				Stats.LastCompletedRunAtUtc = CompletedReferenceUtc;
			}
		}

		for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptEntry : RunRecord.AttemptHistory)
		{
			if (!AttemptEntry.CaseId.IsEmpty())
			{
				TrackedCaseIds.Add(AttemptEntry.CaseId);
			}

			Accumulator.AddAttempt(AttemptEntry);
		}
	}

	Stats.TrackedCaseCount = TrackedCaseIds.Num();
	Stats.AttemptCount = Accumulator.AttemptCount;
	Stats.SolveCount = Accumulator.SolveCount;
	Stats.SuccessCount = Accumulator.SuccessCount;
	Stats.FailureCount = Accumulator.FailureCount;
	Stats.TimeoutCount = Accumulator.TimeoutCount;
	Stats.DNFCount = Accumulator.DNFCount;
	Stats.AbortedCount = Accumulator.AbortedCount;
	Stats.MistakeAttemptCount = Accumulator.MistakeAttemptCount;
	Stats.SmartDeviceAttemptCount = Accumulator.SmartDeviceAttemptCount;
	Stats.SmartDeviceSolveCount = Accumulator.SmartDeviceSolveCount;
	Stats.RecognitionAttemptCount = Accumulator.RecognitionAttemptCount;
	Stats.RecognitionSolveCount = Accumulator.RecognitionSolveCount;
	Stats.BestExecutionTimeMs = Accumulator.BestExecutionTimeMs;
	Stats.BestRecognitionTimeMs = Accumulator.BestRecognitionTimeMs;
	Stats.BestTotalTimeMs = Accumulator.BestTotalTimeMs;
	Stats.BestRawSolveTimeMs = Accumulator.BestRawSolveTimeMs;
	Stats.AverageExecutionTimeMs = Accumulator.ExecutionSampleCount > 0
		? static_cast<int32>(Accumulator.ExecutionTimeAccumulator / Accumulator.ExecutionSampleCount)
		: 0;
	Stats.AverageRecognitionTimeMs = Accumulator.RecognitionSampleCount > 0
		? static_cast<int32>(Accumulator.RecognitionTimeAccumulator / Accumulator.RecognitionSampleCount)
		: 0;
	Stats.AverageTotalTimeMs = Accumulator.TotalSampleCount > 0
		? static_cast<int32>(Accumulator.TotalTimeAccumulator / Accumulator.TotalSampleCount)
		: 0;
	Stats.AverageRawSolveTimeMs = Accumulator.RawSolveSampleCount > 0
		? static_cast<int32>(Accumulator.RawSolveTimeAccumulator / Accumulator.RawSolveSampleCount)
		: 0;
	Stats.AverageInspectionTimeMs = Accumulator.InspectionSampleCount > 0
		? static_cast<int32>(Accumulator.InspectionTimeAccumulator / Accumulator.InspectionSampleCount)
		: 0;
	Stats.Plus2PenaltyCount = Accumulator.Plus2PenaltyCount;
	Stats.AverageCompletedRunWallTimeMs = CompletedRunWallSamples > 0
		? static_cast<int32>(CompletedRunWallAccumulator / CompletedRunWallSamples)
		: 0;
	Stats.PrimaryDeliveryMode = Accumulator.ResolvePrimaryDeliveryMode();
	Stats.LastAttemptAtUtc = Accumulator.LastAttemptAtUtc;

	return Stats;
}

FHyperTwistTrainingTemplateLaunchScopedStats UHyperTwistTrainingRepositoryLibrary::DeriveTemplateLaunchScopedStats(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& TemplateId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingTemplateLaunchScopedStats ScopedStats;
	if (UserId.IsEmpty() || TemplateId.IsEmpty())
	{
		return ScopedStats;
	}

	const TArray<FHyperTwistTrainingTemplateLaunchScopedStats> TemplateScopedStats =
		ListTemplateLaunchScopedStatsForUser(
			RepositoryState,
			UserId,
			ReferenceUtc
		);
	const FHyperTwistTrainingTemplateLaunchScopedStats* ExistingStats =
		TemplateScopedStats.FindByPredicate(
			[&TemplateId](const FHyperTwistTrainingTemplateLaunchScopedStats& Candidate)
			{
				return Candidate.TemplateId == TemplateId;
			}
		);
	return ExistingStats != nullptr ? *ExistingStats : ScopedStats;
}

TArray<FHyperTwistTrainingTemplateLaunchScopedStats>
UHyperTwistTrainingRepositoryLibrary::ListTemplateLaunchScopedStatsForUser(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	TArray<FHyperTwistTrainingTemplateLaunchScopedStats> ScopedStats;
	if (UserId.IsEmpty())
	{
		return ScopedStats;
	}

	struct FTemplateLaunchScopedStatsAccumulator
	{
		struct FSelectionScopedAccumulator
		{
			FHyperTwistTrainingTemplateLaunchSelectionScopedStats Stats;
			int64 MistakeAccumulator = 0;
			int32 OutcomeRunSampleCount = 0;
		};

		FHyperTwistTrainingTemplateLaunchScopedStats Stats;
		int64 RecommendedCaseAccumulator = 0;
		int64 FocusCaseAccumulator = 0;
		int64 CompletedAttemptAccumulator = 0;
		int64 MistakeAccumulator = 0;
		int32 OutcomeRunSampleCount = 0;
		FSelectionScopedAccumulator DashboardPrimarySelectionAccumulator;
		FSelectionScopedAccumulator DashboardAnalyticsTieBreakSelectionAccumulator;
		FSelectionScopedAccumulator DashboardAnalyticsTieBreakTemplateScopedSignalAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalBroaderOutcomeOnlyAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceLaneBiasAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalNoSupportBiasSnapshotGuardAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardNoDecisionBiasAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardPlainAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardDecisionBiasSnapshotGuardAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotEarnedAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotSuppressedAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotNoRetainedAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotEarnedAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotSuppressedAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotNoRetainedAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalNoRetainedComparablePeerConfidenceLaneAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceEligibleAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakTemplateScopedSignalSuppressedPeerNoEvidenceHeavyAccumulator;
		FSelectionScopedAccumulator DashboardAnalyticsTieBreakSelectorSplitConfidenceAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakSelectorSplitConfidencePeerLackedComparableEvidenceAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedWeakerSupportKindAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedMarginalSupportKindAccumulator;
		FSelectionScopedAccumulator
			DashboardAnalyticsTieBreakSelectorSplitConfidencePeerClearedComparableGuardAccumulator;
	};

	const FString ResolvedReferenceUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	const TArray<FHyperTwistTrainingRunRecord> RunRecords =
		ListRunRecordsForDeck(RepositoryState, UserId, FString());
	TArray<FTemplateLaunchScopedStatsAccumulator> Accumulators;
	TMap<FString, int32> AccumulatorIndexByTemplateId;
	for (const FHyperTwistTrainingRunRecord& RunRecord : RunRecords)
	{
		if (!RunRecord.IsStructurallyValid()
			|| !RunRecord.TemplateLaunchProvenance.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingTemplateLaunchProvenance& Provenance =
			RunRecord.TemplateLaunchProvenance;
		const FString ScopedUserId = !Provenance.UserId.IsEmpty()
			? Provenance.UserId
			: RunRecord.Session.UserId;
		if (ScopedUserId != UserId)
		{
			continue;
		}

		int32* ExistingIndex = AccumulatorIndexByTemplateId.Find(Provenance.TemplateId);
		if (ExistingIndex == nullptr)
		{
			FTemplateLaunchScopedStatsAccumulator Accumulator;
			Accumulator.Stats.UserId = UserId;
			Accumulator.Stats.TemplateId = Provenance.TemplateId;
			Accumulator.Stats.ReferenceUtc = ResolvedReferenceUtc;
			Accumulator.Stats.SourceTemplateId = Provenance.SourceTemplateId;
			Accumulator.Stats.Title = Provenance.Title;
			Accumulator.Stats.FocusDeckId = Provenance.FocusDeckId;
			Accumulator.Stats.SourceReviewPlanId = Provenance.SourceReviewPlanId;
			Accumulator.Stats.TemplateKind = Provenance.TemplateKind;
			Accumulator.Stats.SuggestedMode = Provenance.SuggestedMode;
			Accumulator.Stats.SuggestedSelectionPolicy = Provenance.SuggestedSelectionPolicy;
			const int32 AddedIndex = Accumulators.Add(MoveTemp(Accumulator));
			AccumulatorIndexByTemplateId.Add(Provenance.TemplateId, AddedIndex);
			ExistingIndex = AccumulatorIndexByTemplateId.Find(Provenance.TemplateId);
		}

		FTemplateLaunchScopedStatsAccumulator& Accumulator = Accumulators[*ExistingIndex];
		const FString LaunchAtUtc = !RunRecord.Session.StartedAtUtc.IsEmpty()
			? RunRecord.Session.StartedAtUtc
			: RunRecord.LastUpdatedAtUtc;
		if (Accumulator.Stats.LastLaunchAtUtc.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				LaunchAtUtc,
				Accumulator.Stats.LastLaunchAtUtc) > 0)
		{
			Accumulator.Stats.SourceTemplateId = Provenance.SourceTemplateId;
			Accumulator.Stats.Title = Provenance.Title;
			Accumulator.Stats.FocusDeckId = Provenance.FocusDeckId;
			Accumulator.Stats.SourceReviewPlanId = Provenance.SourceReviewPlanId;
			Accumulator.Stats.TemplateKind = Provenance.TemplateKind;
			Accumulator.Stats.SuggestedMode = Provenance.SuggestedMode;
			Accumulator.Stats.SuggestedSelectionPolicy = Provenance.SuggestedSelectionPolicy;
			Accumulator.Stats.LastLaunchAtUtc = LaunchAtUtc;
			Accumulator.Stats.LastSessionId = RunRecord.Session.TrainingSessionId;
		}

		Accumulator.Stats.LaunchCount += 1;
		Accumulator.Stats.TotalAttemptCount += RunRecord.Summary.AttemptCount;
		Accumulator.Stats.TotalCompletedAttemptCount += RunRecord.Summary.CompletedAttemptCount;
		Accumulator.Stats.TotalSuccessCount += RunRecord.Summary.SuccessCount;
		Accumulator.Stats.TotalFailureCount += RunRecord.Summary.FailureCount;
		Accumulator.Stats.TotalTimeoutCount += RunRecord.Summary.TimeoutCount;
		Accumulator.Stats.TotalDNFCount += RunRecord.Summary.DNFCount;
		Accumulator.Stats.TotalMistakes += RunRecord.Summary.TotalMistakes;
		Accumulator.RecommendedCaseAccumulator += FMath::Max(Provenance.RecommendedCaseCount, 0);
		Accumulator.FocusCaseAccumulator += Provenance.FocusCaseIds.Num();

		const bool bReviewBackedLaunch =
			Provenance.bPreferReviewRun
			|| Provenance.TemplateKind == EHyperTwistTrainingSessionTemplateKind::ReviewPlan
			|| Provenance.TemplateKind == EHyperTwistTrainingSessionTemplateKind::Coach;
		if (bReviewBackedLaunch)
		{
			Accumulator.Stats.ReviewBackedLaunchCount += 1;
		}
		if (Provenance.bCoachReview)
		{
			Accumulator.Stats.CoachReviewLaunchCount += 1;
		}
		if (Provenance.bPreferShortReviewSet)
		{
			Accumulator.Stats.ShortReviewSetLaunchCount += 1;
		}

		auto AccumulateSelectionScopedStats =
			[&RunRecord](
				FTemplateLaunchScopedStatsAccumulator::FSelectionScopedAccumulator& SelectionAccumulator,
				const FHyperTwistTrainingTemplateLaunchSelectionProvenance& SelectionProvenance)
			{
				SelectionAccumulator.Stats.SelectorSourceLabel = SelectionProvenance.SelectorSourceLabel;
				SelectionAccumulator.Stats.ReasonClass = SelectionProvenance.ReasonClass;
				SelectionAccumulator.Stats.AnalyticsSupportKind =
					SelectionProvenance.AnalyticsSupportKind;
				SelectionAccumulator.Stats.PeerSupportKindDisposition =
					SelectionProvenance.PeerSupportKindDisposition;
				SelectionAccumulator.Stats.LaunchCount += 1;
				SelectionAccumulator.Stats.TotalCompletedAttemptCount +=
					RunRecord.Summary.CompletedAttemptCount;
				SelectionAccumulator.Stats.TotalSuccessCount += RunRecord.Summary.SuccessCount;

				if (RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Completed)
				{
					SelectionAccumulator.Stats.CompletedRunCount += 1;
				}
				else if (RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Aborted)
				{
					SelectionAccumulator.Stats.AbortedRunCount += 1;
				}
				else
				{
					SelectionAccumulator.Stats.OpenRunCount += 1;
				}

				if (RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Completed
					|| RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Aborted)
				{
					SelectionAccumulator.MistakeAccumulator += RunRecord.Summary.TotalMistakes;
					SelectionAccumulator.OutcomeRunSampleCount += 1;
				}
			};
		if (Provenance.SelectionProvenance.IsStructurallyValid()
			&& Provenance.SelectionProvenance.SelectorSourceLabel == TEXT("CoachDashboard"))
		{
			if (Provenance.SelectionProvenance.ReasonClass ==
				EHyperTwistTrainingTemplateLaunchSelectionReasonClass::PrimaryDashboardPriority)
			{
				AccumulateSelectionScopedStats(
					Accumulator.DashboardPrimarySelectionAccumulator,
					Provenance.SelectionProvenance
				);
			}
			else if (Provenance.SelectionProvenance.ReasonClass ==
				EHyperTwistTrainingTemplateLaunchSelectionReasonClass::AnalyticsTieBreak)
			{
				AccumulateSelectionScopedStats(
					Accumulator.DashboardAnalyticsTieBreakSelectionAccumulator,
					Provenance.SelectionProvenance
				);
				if (Provenance.SelectionProvenance.AnalyticsSupportKind ==
					EHyperTwistTrainingTemplateLaunchSelectionAnalyticsSupportKind::TemplateScopedOutcomeSignal)
				{
					AccumulateSelectionScopedStats(
						Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalAccumulator,
						Provenance.SelectionProvenance
					);
					if (Provenance.SelectionProvenance.TemplateSignalSupportKind ==
						EHyperTwistTrainingTemplateLaunchSelectionTemplateSignalSupportKind::
							ConfidenceLaneBias)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceLaneBiasAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalBroaderOutcomeOnlyAccumulator,
							Provenance.SelectionProvenance
						);
					}
					if (Provenance.SelectionProvenance.TemplateSignalSupportDecisionKind ==
						EHyperTwistTrainingTemplateLaunchSelectionTemplateSignalSupportDecisionKind::
							SupportBiasSnapshotGuard)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardAccumulator,
							Provenance.SelectionProvenance
						);
						if (Provenance.SelectionProvenance.TemplateSignalSupportDecisionBiasKind ==
							EHyperTwistTrainingTemplateLaunchSelectionTemplateSignalSupportDecisionBiasKind::
								DecisionSplitGuard)
						{
							AccumulateSelectionScopedStats(
								Accumulator
									.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardAccumulator,
								Provenance.SelectionProvenance
							);
							if (Provenance.SelectionProvenance
									.TemplateSignalSupportDecisionBiasSnapshotDecisionKind
								==
								EHyperTwistTrainingTemplateLaunchSelectionTemplateSignalSupportDecisionBiasSnapshotDecisionKind::
									DecisionBiasSnapshotGuard)
							{
								AccumulateSelectionScopedStats(
									Accumulator
										.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardDecisionBiasSnapshotGuardAccumulator,
									Provenance.SelectionProvenance
								);
							}
							else
							{
								AccumulateSelectionScopedStats(
									Accumulator
										.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardPlainAccumulator,
									Provenance.SelectionProvenance
								);
							}
						}
						else
						{
							AccumulateSelectionScopedStats(
								Accumulator
									.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardNoDecisionBiasAccumulator,
								Provenance.SelectionProvenance
							);
						}
					}
					else
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalNoSupportBiasSnapshotGuardAccumulator,
							Provenance.SelectionProvenance
						);
					}
					const EHyperTwistTrainingTemplateLaunchTemplateSignalSupportBiasSnapshotState
						SupportBiasSnapshotState =
							Provenance.SelectionProvenance.TemplateSignalSupportBiasSnapshot.State;
					if (SupportBiasSnapshotState ==
						EHyperTwistTrainingTemplateLaunchTemplateSignalSupportBiasSnapshotState::Earned)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotEarnedAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else if (
						SupportBiasSnapshotState ==
						EHyperTwistTrainingTemplateLaunchTemplateSignalSupportBiasSnapshotState::Suppressed)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotSuppressedAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotNoRetainedAccumulator,
							Provenance.SelectionProvenance
						);
					}
					const EHyperTwistTrainingTemplateLaunchTemplateSignalSupportDecisionBiasSnapshotState
						DecisionBiasSnapshotState =
							Provenance.SelectionProvenance
								.TemplateSignalSupportDecisionBiasSnapshot
								.State;
					if (DecisionBiasSnapshotState ==
						EHyperTwistTrainingTemplateLaunchTemplateSignalSupportDecisionBiasSnapshotState::Earned)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotEarnedAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else if (
						DecisionBiasSnapshotState ==
						EHyperTwistTrainingTemplateLaunchTemplateSignalSupportDecisionBiasSnapshotState::Suppressed)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotSuppressedAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotNoRetainedAccumulator,
							Provenance.SelectionProvenance
						);
					}
					const EHyperTwistTrainingTemplateLaunchComparablePeerConfidenceSnapshotState
						SnapshotState =
							Provenance.SelectionProvenance.ComparablePeerConfidenceSnapshot.State;
					if (SnapshotState ==
						EHyperTwistTrainingTemplateLaunchComparablePeerConfidenceSnapshotState::
							ConfidenceEligible)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceEligibleAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else if (
						SnapshotState ==
						EHyperTwistTrainingTemplateLaunchComparablePeerConfidenceSnapshotState::
							SuppressedPeerNoEvidenceHeavy)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalSuppressedPeerNoEvidenceHeavyAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakTemplateScopedSignalNoRetainedComparablePeerConfidenceLaneAccumulator,
							Provenance.SelectionProvenance
						);
					}
				}
				else if (Provenance.SelectionProvenance.AnalyticsSupportKind ==
					EHyperTwistTrainingTemplateLaunchSelectionAnalyticsSupportKind::SelectorSplitConfidence)
				{
					AccumulateSelectionScopedStats(
						Accumulator.DashboardAnalyticsTieBreakSelectorSplitConfidenceAccumulator,
						Provenance.SelectionProvenance
					);
					if (Provenance.SelectionProvenance.PeerSupportKindDisposition ==
						EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::
							PeerLackedComparableEvidence)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerLackedComparableEvidenceAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else if (Provenance.SelectionProvenance.PeerSupportKindDisposition ==
						EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::
							PeerFailedGuardOnWeakerSupportKindOutcomes)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedWeakerSupportKindAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else if (Provenance.SelectionProvenance.PeerSupportKindDisposition ==
						EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::
							PeerFailedGuardOnMarginalSupportKindOutcomes)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedMarginalSupportKindAccumulator,
							Provenance.SelectionProvenance
						);
					}
					else if (Provenance.SelectionProvenance.PeerSupportKindDisposition ==
						EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::
							PeerClearedComparableSupportKindGuard)
					{
						AccumulateSelectionScopedStats(
							Accumulator
								.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerClearedComparableGuardAccumulator,
							Provenance.SelectionProvenance
						);
					}
				}
			}
		}

		if (RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Completed)
		{
			Accumulator.Stats.CompletedRunCount += 1;
		}
		else if (RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Aborted)
		{
			Accumulator.Stats.AbortedRunCount += 1;
		}
		else
		{
			Accumulator.Stats.OpenRunCount += 1;
		}

		if (RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Completed
			|| RunRecord.Session.SessionState == EHyperTwistTrainingSessionState::Aborted)
		{
			const FString CompletedAtUtc = !RunRecord.Summary.LastCompletedAtUtc.IsEmpty()
				? RunRecord.Summary.LastCompletedAtUtc
				: RunRecord.Session.EndedAtUtc;
			if (!CompletedAtUtc.IsEmpty()
				&& (Accumulator.Stats.LastCompletedAtUtc.IsEmpty()
					|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
						CompletedAtUtc,
						Accumulator.Stats.LastCompletedAtUtc) > 0))
			{
				Accumulator.Stats.LastCompletedAtUtc = CompletedAtUtc;
			}

			Accumulator.CompletedAttemptAccumulator += RunRecord.Summary.CompletedAttemptCount;
			Accumulator.MistakeAccumulator += RunRecord.Summary.TotalMistakes;
			Accumulator.OutcomeRunSampleCount += 1;
		}
	}

	for (FTemplateLaunchScopedStatsAccumulator& Accumulator : Accumulators)
	{
		Accumulator.Stats.AverageRecommendedCaseCount = Accumulator.Stats.LaunchCount > 0
			? static_cast<int32>(
				Accumulator.RecommendedCaseAccumulator / Accumulator.Stats.LaunchCount)
			: 0;
		Accumulator.Stats.AverageFocusCaseCount = Accumulator.Stats.LaunchCount > 0
			? static_cast<int32>(
				Accumulator.FocusCaseAccumulator / Accumulator.Stats.LaunchCount)
			: 0;
		Accumulator.Stats.AverageCompletedAttemptCount = Accumulator.OutcomeRunSampleCount > 0
			? static_cast<int32>(
				Accumulator.CompletedAttemptAccumulator / Accumulator.OutcomeRunSampleCount)
			: 0;
		Accumulator.Stats.OverallSuccessRate = Accumulator.Stats.TotalCompletedAttemptCount > 0
			? static_cast<float>(Accumulator.Stats.TotalSuccessCount)
				/ static_cast<float>(Accumulator.Stats.TotalCompletedAttemptCount)
			: 0.0f;
		Accumulator.Stats.AverageMistakesPerOutcomeRun = Accumulator.OutcomeRunSampleCount > 0
			? static_cast<float>(Accumulator.MistakeAccumulator)
				/ static_cast<float>(Accumulator.OutcomeRunSampleCount)
			: 0.0f;
		auto FinalizeSelectionScopedAccumulator =
			[](
				FTemplateLaunchScopedStatsAccumulator::FSelectionScopedAccumulator& SelectionAccumulator)
			{
				SelectionAccumulator.Stats.OverallSuccessRate =
					SelectionAccumulator.Stats.TotalCompletedAttemptCount > 0
						? static_cast<float>(SelectionAccumulator.Stats.TotalSuccessCount)
							/ static_cast<float>(
								SelectionAccumulator.Stats.TotalCompletedAttemptCount)
						: 0.0f;
				SelectionAccumulator.Stats.AverageMistakesPerOutcomeRun =
					SelectionAccumulator.OutcomeRunSampleCount > 0
						? static_cast<float>(SelectionAccumulator.MistakeAccumulator)
							/ static_cast<float>(SelectionAccumulator.OutcomeRunSampleCount)
						: 0.0f;
			};
		FinalizeSelectionScopedAccumulator(Accumulator.DashboardPrimarySelectionAccumulator);
		FinalizeSelectionScopedAccumulator(
			Accumulator.DashboardAnalyticsTieBreakSelectionAccumulator
		);
		Accumulator.DashboardPrimarySelectionAccumulator.Stats.AnalyticsSupportKind =
			EHyperTwistTrainingTemplateLaunchSelectionAnalyticsSupportKind::None;
		Accumulator.DashboardAnalyticsTieBreakSelectionAccumulator.Stats.AnalyticsSupportKind =
			EHyperTwistTrainingTemplateLaunchSelectionAnalyticsSupportKind::None;
		FinalizeSelectionScopedAccumulator(
			Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalBroaderOutcomeOnlyAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceLaneBiasAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalNoSupportBiasSnapshotGuardAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardNoDecisionBiasAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotEarnedAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotSuppressedAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotNoRetainedAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalNoRetainedComparablePeerConfidenceLaneAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceEligibleAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalSuppressedPeerNoEvidenceHeavyAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator.DashboardAnalyticsTieBreakSelectorSplitConfidenceAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerLackedComparableEvidenceAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedWeakerSupportKindAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedMarginalSupportKindAccumulator
		);
		FinalizeSelectionScopedAccumulator(
			Accumulator
				.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerClearedComparableGuardAccumulator
		);
		Accumulator.DashboardPrimarySelectionAccumulator.Stats.PeerSupportKindDisposition =
			EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator.DashboardAnalyticsTieBreakSelectionAccumulator.Stats.PeerSupportKindDisposition =
			EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalAccumulator.Stats
			.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalBroaderOutcomeOnlyAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceLaneBiasAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalNoSupportBiasSnapshotGuardAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardNoDecisionBiasAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotEarnedAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotSuppressedAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotNoRetainedAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalNoRetainedComparablePeerConfidenceLaneAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceEligibleAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator
			.DashboardAnalyticsTieBreakTemplateScopedSignalSuppressedPeerNoEvidenceHeavyAccumulator
			.Stats.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator.DashboardAnalyticsTieBreakSelectorSplitConfidenceAccumulator.Stats
			.PeerSupportKindDisposition =
				EHyperTwistTrainingTemplateLaunchSelectionPeerSupportKindDisposition::None;
		Accumulator.Stats.DashboardPrimarySelectionStats =
			Accumulator.DashboardPrimarySelectionAccumulator.Stats;
		Accumulator.Stats.DashboardAnalyticsTieBreakStats =
			Accumulator.DashboardAnalyticsTieBreakSelectionAccumulator.Stats;
		Accumulator.Stats.DashboardAnalyticsTieBreakTemplateScopedSignalStats =
			Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalAccumulator.Stats;
		Accumulator.Stats.DashboardAnalyticsTieBreakTemplateScopedSignalBroaderOutcomeOnlyStats =
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalBroaderOutcomeOnlyAccumulator
				.Stats;
		Accumulator.Stats.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceLaneBiasStats =
			Accumulator
				.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceLaneBiasAccumulator
				.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalNoSupportBiasSnapshotGuardStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalNoSupportBiasSnapshotGuardAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardNoDecisionBiasStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardNoDecisionBiasAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardPlainStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardPlainAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardDecisionBiasSnapshotGuardStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotGuardDecisionSplitGuardDecisionBiasSnapshotGuardAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotEarnedStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotEarnedAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotSuppressedStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotSuppressedAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotNoRetainedStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportBiasSnapshotNoRetainedAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotEarnedStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotEarnedAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotSuppressedStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotSuppressedAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotNoRetainedStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSupportDecisionBiasSnapshotNoRetainedAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalNoRetainedComparablePeerConfidenceLaneStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalNoRetainedComparablePeerConfidenceLaneAccumulator
					.Stats;
		Accumulator.Stats.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceEligibleStats =
			Accumulator.DashboardAnalyticsTieBreakTemplateScopedSignalConfidenceEligibleAccumulator
				.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakTemplateScopedSignalSuppressedPeerNoEvidenceHeavyStats =
				Accumulator
					.DashboardAnalyticsTieBreakTemplateScopedSignalSuppressedPeerNoEvidenceHeavyAccumulator
					.Stats;
		Accumulator.Stats.DashboardAnalyticsTieBreakSelectorSplitConfidenceStats =
			Accumulator.DashboardAnalyticsTieBreakSelectorSplitConfidenceAccumulator.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerLackedComparableEvidenceStats =
				Accumulator
					.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerLackedComparableEvidenceAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedWeakerSupportKindStats =
				Accumulator
					.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedWeakerSupportKindAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedMarginalSupportKindStats =
				Accumulator
					.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerFailedMarginalSupportKindAccumulator
					.Stats;
		Accumulator.Stats
			.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerClearedComparableGuardStats =
				Accumulator
					.DashboardAnalyticsTieBreakSelectorSplitConfidencePeerClearedComparableGuardAccumulator
					.Stats;
		if (Accumulator.Stats.IsStructurallyValid())
		{
			ScopedStats.Add(Accumulator.Stats);
		}
	}

	ScopedStats.Sort([](
		const FHyperTwistTrainingTemplateLaunchScopedStats& Left,
		const FHyperTwistTrainingTemplateLaunchScopedStats& Right
	)
	{
		const int32 LaunchAtCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastLaunchAtUtc,
			Right.LastLaunchAtUtc
		);
		if (LaunchAtCompare != 0)
		{
			return LaunchAtCompare > 0;
		}
		if (Left.LaunchCount != Right.LaunchCount)
		{
			return Left.LaunchCount > Right.LaunchCount;
		}

		return Left.TemplateId < Right.TemplateId;
	});

	return ScopedStats;
}

FHyperTwistTrainingLearnerDeckStateSummary UHyperTwistTrainingRepositoryLibrary::DeriveLearnerDeckStateSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& DeckId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingLearnerDeckStateSummary Summary;
	Summary.UserId = UserId;
	Summary.DeckId = DeckId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingCaseLearnerState> LearnerStates = ListLearnerStatesForDeck(
		RepositoryState,
		UserId,
		DeckId
	);

	double StabilityAccumulator = 0.0;
	double DifficultyAccumulator = 0.0;

	for (const FHyperTwistTrainingCaseLearnerState& LearnerState : LearnerStates)
	{
		Summary.TrackedCaseCount += 1;
		StabilityAccumulator += LearnerState.StabilityDays;
		DifficultyAccumulator += LearnerState.DifficultyScore;

		if (LearnerState.ReviewCount <= 0)
		{
			Summary.NewCaseCount += 1;
		}
		else if (LearnerState.StabilityDays >= HyperTwistTrainingRepositoryLibraryInternal::MatureStabilityDays)
		{
			Summary.MatureCaseCount += 1;
		}
		else
		{
			Summary.LearningCaseCount += 1;
		}

		if (!LearnerState.DueAtUtc.IsEmpty())
		{
			const int32 DueCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				LearnerState.DueAtUtc,
				Summary.ReferenceUtc
			);
			if (DueCompare <= 0)
			{
				Summary.DueCaseCount += 1;
			}
			if (DueCompare < 0)
			{
				Summary.OverdueCaseCount += 1;
			}
			if (Summary.NextDueAtUtc.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(LearnerState.DueAtUtc, Summary.NextDueAtUtc) < 0)
			{
				Summary.NextDueAtUtc = LearnerState.DueAtUtc;
			}
		}
		else
		{
			Summary.DueCaseCount += 1;
		}

		if (Summary.LastReviewedAtUtc.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(LearnerState.LastReviewedAtUtc, Summary.LastReviewedAtUtc) > 0)
		{
			Summary.LastReviewedAtUtc = LearnerState.LastReviewedAtUtc;
		}
	}

	if (Summary.TrackedCaseCount > 0)
	{
		Summary.AverageStabilityDays = static_cast<float>(StabilityAccumulator / Summary.TrackedCaseCount);
		Summary.AverageDifficultyScore = static_cast<float>(DifficultyAccumulator / Summary.TrackedCaseCount);
	}

	return Summary;
}

FHyperTwistTrainingLearnerProfile UHyperTwistTrainingRepositoryLibrary::DeriveLearnerProfile(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingLearnerProfile Profile;
	if (UserId.IsEmpty())
	{
		return Profile;
	}

	Profile.UserId = UserId;
	Profile.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	TMap<FString, int32> SessionCountByDeck;
	TMap<EHyperTwistTrainingDeliveryMode, int32> SessionCountByMode;
	TSet<int64> UniqueTrainingDays;
	int64 TotalTimedAttemptMs = 0;
	int32 TimedAttemptCount = 0;
	FDateTime ReferenceDate;
	const bool bHasReferenceDate = HyperTwistTrainingRepositoryLibraryInternal::TryParseUtc(Profile.ReferenceUtc, ReferenceDate);
	const FDateTime ReferenceDay = bHasReferenceDate
		? FDateTime(ReferenceDate.GetYear(), ReferenceDate.GetMonth(), ReferenceDate.GetDay())
		: FDateTime();

	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (!RunRecord.IsStructurallyValid() || RunRecord.Session.UserId != UserId)
		{
			continue;
		}

		Profile.TotalSessionCount += 1;
		if (RunRecord.bCompleted)
		{
			Profile.CompletedSessionCount += 1;
		}

		Profile.TotalAttemptCount += RunRecord.Summary.AttemptCount;
		Profile.TotalSuccessCount += RunRecord.Summary.SuccessCount;
		Profile.TotalFailureCount += RunRecord.Summary.FailureCount
			+ RunRecord.Summary.TimeoutCount
			+ RunRecord.Summary.DNFCount
			+ RunRecord.Summary.AbortedCount;
		SessionCountByDeck.FindOrAdd(RunRecord.Session.DeckId) += 1;
		SessionCountByMode.FindOrAdd(RunRecord.Session.Mode) += 1;

		for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptHistoryEntry : RunRecord.AttemptHistory)
		{
			if (AttemptHistoryEntry.TotalTimeMs > 0)
			{
				TotalTimedAttemptMs += AttemptHistoryEntry.TotalTimeMs;
				TimedAttemptCount += 1;
			}
		}

		const FString LastTrainingAtUtc = !RunRecord.LastUpdatedAtUtc.IsEmpty()
			? RunRecord.LastUpdatedAtUtc
			: RunRecord.Session.EndedAtUtc;
		if (Profile.LastTrainingAtUtc.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(LastTrainingAtUtc, Profile.LastTrainingAtUtc) > 0)
		{
			Profile.LastTrainingAtUtc = LastTrainingAtUtc;
		}

		FDateTime TrainingDate;
		if (HyperTwistTrainingRepositoryLibraryInternal::TryParseUtc(LastTrainingAtUtc, TrainingDate))
		{
			const FDateTime TrainingDay = FDateTime(TrainingDate.GetYear(), TrainingDate.GetMonth(), TrainingDate.GetDay());
			UniqueTrainingDays.Add(TrainingDay.GetTicks());

			if (bHasReferenceDate)
			{
				const double DayDelta = (ReferenceDay - TrainingDay).GetTotalDays();
				if (DayDelta >= 0.0 && DayDelta < 7.0)
				{
					Profile.RecentSevenDaySessionCount += 1;
					if (RunRecord.bCompleted)
					{
						Profile.RecentSevenDayCompletedSessionCount += 1;
					}
				}
			}
		}
	}

	for (const TPair<FString, int32>& Pair : SessionCountByDeck)
	{
		Profile.DeckCount += 1;
		if (Profile.FavoriteDeckId.IsEmpty()
			|| Pair.Value > SessionCountByDeck.FindRef(Profile.FavoriteDeckId)
			|| (Pair.Value == SessionCountByDeck.FindRef(Profile.FavoriteDeckId) && Pair.Key < Profile.FavoriteDeckId))
		{
			Profile.FavoriteDeckId = Pair.Key;
		}
	}
	if (!Profile.FavoriteDeckId.IsEmpty() && Profile.TotalSessionCount > 0)
	{
		Profile.FavoriteDeckSessionShare = static_cast<float>(SessionCountByDeck.FindRef(Profile.FavoriteDeckId))
			/ static_cast<float>(Profile.TotalSessionCount);
	}

	const TArray<FHyperTwistTrainingMethodSegment> MethodSegments = DeriveLearnerMethodSegments(
		RepositoryState,
		UserId,
		Profile.ReferenceUtc
	);
	int32 FavoriteMethodSessionCount = -1;
	for (const FHyperTwistTrainingMethodSegment& MethodSegment : MethodSegments)
	{
		if (!MethodSegment.IsStructurallyValid())
		{
			continue;
		}

		if (MethodSegment.SessionCount > FavoriteMethodSessionCount
			|| (MethodSegment.SessionCount == FavoriteMethodSessionCount
				&& (Profile.FavoriteMethodSegmentId.IsEmpty()
					|| MethodSegment.MethodDescriptor.SegmentId < Profile.FavoriteMethodSegmentId)))
		{
			FavoriteMethodSessionCount = MethodSegment.SessionCount;
			Profile.FavoriteMethodSegmentId = MethodSegment.MethodDescriptor.SegmentId;
		}
	}
	if (FavoriteMethodSessionCount > 0 && Profile.TotalSessionCount > 0)
	{
		Profile.FavoriteMethodSegmentSessionShare = static_cast<float>(FavoriteMethodSessionCount)
			/ static_cast<float>(Profile.TotalSessionCount);
	}

	int32 BestModeCount = -1;
	for (const TPair<EHyperTwistTrainingDeliveryMode, int32>& Pair : SessionCountByMode)
	{
		if (Pair.Value > BestModeCount)
		{
			BestModeCount = Pair.Value;
			Profile.PrimaryDeliveryMode = Pair.Key;
		}
	}

	for (const FHyperTwistTrainingCaseLearnerState& LearnerState : RepositoryState.LearnerStates)
	{
		if (!LearnerState.IsStructurallyValid() || LearnerState.UserId != UserId)
		{
			continue;
		}

		Profile.TotalTrackedCaseCount += 1;
		if (LearnerState.ReviewCount <= 0)
		{
			continue;
		}

		if (LearnerState.StabilityDays >= HyperTwistTrainingRepositoryLibraryInternal::MatureStabilityDays)
		{
			Profile.MatureCaseCount += 1;
		}
		else
		{
			Profile.LearningCaseCount += 1;
		}

		if (!LearnerState.DueAtUtc.IsEmpty())
		{
			const int32 DueCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				LearnerState.DueAtUtc,
				Profile.ReferenceUtc
			);
			if (DueCompare <= 0)
			{
				Profile.DueCaseCount += 1;
			}
			if (DueCompare < 0)
			{
				Profile.OverdueCaseCount += 1;
			}
		}
		else
		{
			Profile.DueCaseCount += 1;
		}
	}

	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : RepositoryState.ReviewPlans)
	{
		if (!ReviewPlan.IsStructurallyValid() || ReviewPlan.UserId != UserId)
		{
			continue;
		}

		if (!ReviewPlan.bCompleted)
		{
			Profile.OpenReviewPlanCount += 1;
		}
	}

	if (Profile.TotalAttemptCount > 0)
	{
		Profile.SuccessRate = static_cast<float>(Profile.TotalSuccessCount) / static_cast<float>(Profile.TotalAttemptCount);
	}
	if (TimedAttemptCount > 0)
	{
		Profile.AverageTotalTimeMs = static_cast<int32>(TotalTimedAttemptMs / TimedAttemptCount);
	}

	TArray<int64> TrainingDayTicks = UniqueTrainingDays.Array();
	TrainingDayTicks.Sort();
	int32 CurrentStreak = 0;
	int32 BestStreak = 0;
	int32 RunningStreak = 0;
	int64 PreviousDayTick = 0;
	bool bHasPreviousDay = false;
	for (const int64 DayTick : TrainingDayTicks)
	{
		if (bHasPreviousDay)
		{
			const int32 DayGap = static_cast<int32>(FTimespan(DayTick - PreviousDayTick).GetTotalDays());
			RunningStreak = DayGap == 1 ? RunningStreak + 1 : 1;
		}
		else
		{
			RunningStreak = 1;
			bHasPreviousDay = true;
		}

		BestStreak = FMath::Max(BestStreak, RunningStreak);
		PreviousDayTick = DayTick;
	}
	if (TrainingDayTicks.Num() > 0)
	{
		CurrentStreak = 1;
		for (int32 Index = TrainingDayTicks.Num() - 2; Index >= 0; --Index)
		{
			const int32 DayGap = static_cast<int32>(FTimespan(TrainingDayTicks[Index + 1] - TrainingDayTicks[Index]).GetTotalDays());
			if (DayGap != 1)
			{
				break;
			}

			CurrentStreak += 1;
		}
	}
	Profile.ActiveTrainingDayStreak = CurrentStreak;
	Profile.LongestObservedTrainingDayStreak = BestStreak;

	return Profile;
}

FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRepositoryLibrary::DeriveCoachMemorySnapshot(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachMemorySnapshot Snapshot;
	if (UserId.IsEmpty())
	{
		return Snapshot;
	}

	Snapshot.UserId = UserId;
	Snapshot.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	TMap<FString, int32> OverdueCountByDeck;
	TMap<FString, int32> DueCountByDeck;
	TArray<FHyperTwistTrainingCaseLearnerState> CandidateStates;

	for (const FHyperTwistTrainingCaseLearnerState& LearnerState : RepositoryState.LearnerStates)
	{
		if (!LearnerState.IsStructurallyValid() || LearnerState.UserId != UserId)
		{
			continue;
		}

		CandidateStates.Add(LearnerState);
		const bool bHasDueDate = !LearnerState.DueAtUtc.IsEmpty();
		const int32 DueCompare = bHasDueDate
			? HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(LearnerState.DueAtUtc, Snapshot.ReferenceUtc)
			: 0;
		if (!bHasDueDate || DueCompare <= 0)
		{
			Snapshot.DueCaseIds.Add(LearnerState.CaseId);
			DueCountByDeck.FindOrAdd(LearnerState.DeckId) += 1;
		}
		if (bHasDueDate && DueCompare < 0)
		{
			Snapshot.OverdueCaseIds.Add(LearnerState.CaseId);
			OverdueCountByDeck.FindOrAdd(LearnerState.DeckId) += 1;
		}
	}

	const FString ResolvedReferenceUtc = Snapshot.ReferenceUtc;
	CandidateStates.Sort([&ResolvedReferenceUtc](const FHyperTwistTrainingCaseLearnerState& Left, const FHyperTwistTrainingCaseLearnerState& Right)
	{
		const bool bLeftOverdue = !Left.DueAtUtc.IsEmpty() && Left.DueAtUtc < ResolvedReferenceUtc;
		const bool bRightOverdue = !Right.DueAtUtc.IsEmpty() && Right.DueAtUtc < ResolvedReferenceUtc;
		if (bLeftOverdue != bRightOverdue)
		{
			return bLeftOverdue;
		}
		if (Left.LapseCount != Right.LapseCount)
		{
			return Left.LapseCount > Right.LapseCount;
		}
		if (!FMath::IsNearlyEqual(Left.DifficultyScore, Right.DifficultyScore))
		{
			return Left.DifficultyScore > Right.DifficultyScore;
		}
		return Left.CaseId < Right.CaseId;
	});

	for (const FHyperTwistTrainingCaseLearnerState& LearnerState : CandidateStates)
	{
		if (Snapshot.WeakCaseIds.Num() >= 5)
		{
			break;
		}
		Snapshot.WeakCaseIds.Add(LearnerState.CaseId);
	}

	int32 BestFocusScore = -1;
	for (const TPair<FString, int32>& Pair : DueCountByDeck)
	{
		const int32 FocusScore = OverdueCountByDeck.FindRef(Pair.Key) * 100 + Pair.Value;
		if (FocusScore > BestFocusScore || (FocusScore == BestFocusScore && Pair.Key < Snapshot.FocusDeckId))
		{
			BestFocusScore = FocusScore;
			Snapshot.FocusDeckId = Pair.Key;
		}
	}

	TArray<TPair<FString, int32>> RecoveryDeckScores;
	for (const TPair<FString, int32>& Pair : DueCountByDeck)
	{
		RecoveryDeckScores.Add(TPair<FString, int32>(Pair.Key, OverdueCountByDeck.FindRef(Pair.Key) * 100 + Pair.Value));
	}
	RecoveryDeckScores.Sort([](const TPair<FString, int32>& Left, const TPair<FString, int32>& Right)
	{
		if (Left.Value != Right.Value)
		{
			return Left.Value > Right.Value;
		}

		return Left.Key < Right.Key;
	});
	for (const TPair<FString, int32>& Pair : RecoveryDeckScores)
	{
		if (Snapshot.RecoveryDeckIds.Num() >= 3)
		{
			break;
		}

		Snapshot.RecoveryDeckIds.Add(Pair.Key);
	}

	const TArray<FHyperTwistTrainingMethodSegment> MethodSegments = DeriveLearnerMethodSegments(
		RepositoryState,
		UserId,
		Snapshot.ReferenceUtc
	);
	for (const FHyperTwistTrainingMethodSegment& MethodSegment : MethodSegments)
	{
		if (!MethodSegment.IsStructurallyValid())
		{
			continue;
		}

		if (Snapshot.FocusMethodSegmentId.IsEmpty())
		{
			Snapshot.FocusMethodSegmentId = MethodSegment.MethodDescriptor.SegmentId;
		}
		if (MethodSegment.DeckIds.Contains(Snapshot.FocusDeckId))
		{
			Snapshot.FocusMethodSegmentId = MethodSegment.MethodDescriptor.SegmentId;
		}
		if (MethodSegment.bNeedsRecovery && Snapshot.RecoveryMethodSegmentIds.Num() < 3)
		{
			Snapshot.RecoveryMethodSegmentIds.AddUnique(MethodSegment.MethodDescriptor.SegmentId);
		}
	}

	FString LatestReviewPlanCreatedAtUtc;
	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : RepositoryState.ReviewPlans)
	{
		if (!ReviewPlan.IsStructurallyValid() || ReviewPlan.UserId != UserId)
		{
			continue;
		}

		if (LatestReviewPlanCreatedAtUtc.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(ReviewPlan.CreatedAtUtc, LatestReviewPlanCreatedAtUtc) > 0)
		{
			LatestReviewPlanCreatedAtUtc = ReviewPlan.CreatedAtUtc;
			Snapshot.LastReviewPlanId = ReviewPlan.PlanId;
		}

		if (!ReviewPlan.bCompleted)
		{
			Snapshot.PendingReviewPlanIds.Add(ReviewPlan.PlanId);
		}

		const FHyperTwistTrainingReviewFlowStatus FlowStatus = DeriveReviewFlowStatus(ReviewPlan);
		if (FlowStatus.bNeedsCoachIntervention)
		{
			Snapshot.bNeedsCoachIntervention = true;
		}
	}

	const FHyperTwistTrainingLearnerProfile Profile = DeriveLearnerProfile(RepositoryState, UserId, Snapshot.ReferenceUtc);
	Snapshot.LastTrainingAtUtc = Profile.LastTrainingAtUtc;
	Snapshot.ActiveTrainingDayStreak = Profile.ActiveTrainingDayStreak;
	if (Snapshot.FocusDeckId.IsEmpty())
	{
		Snapshot.FocusDeckId = Profile.FavoriteDeckId;
	}
	if (Snapshot.FocusMethodSegmentId.IsEmpty())
	{
		Snapshot.FocusMethodSegmentId = Profile.FavoriteMethodSegmentId;
	}

	const FHyperTwistTrainingCoachClosureMemorySummary ClosureMemory = DeriveCoachClosureMemorySummary(
		RepositoryState,
		UserId,
		Snapshot.ReferenceUtc
	);
	const FHyperTwistTrainingCoachRecommendationHistorySummary RecommendationHistory =
		DeriveCoachRecommendationHistorySummary(
			RepositoryState,
			UserId,
			Snapshot.ReferenceUtc
		);
	const FHyperTwistTrainingCoachCarryForwardPolicySummary CarryForwardPolicy =
		DeriveCoachCarryForwardPolicySummary(
			RepositoryState,
			UserId,
			Snapshot.ReferenceUtc
		);
	const FHyperTwistTrainingCoachArchivePolicySummary ArchivePolicy =
		DeriveCoachArchivePolicySummary(
			RepositoryState,
			UserId,
			Snapshot.ReferenceUtc
		);
	if (ClosureMemory.IsStructurallyValid())
	{
		Snapshot.ArchivedResolvedCaseIds = ClosureMemory.ArchivedResolvedCaseIds;
		Snapshot.PersistentCoachWeakCaseIds = ClosureMemory.PersistentWeakCaseIds;
		Snapshot.EscalationCaseIds = ClosureMemory.EscalationCaseIds;
		Snapshot.ClosedCoachSequenceCount = ClosureMemory.ClosedSequenceCount;
		Snapshot.EscalatedCoachSequenceCount = ClosureMemory.EscalatedSequenceCount;
		Snapshot.FollowUpReadyCoachSequenceCount = ClosureMemory.FollowUpReadySequenceCount;
		Snapshot.RecoverySustainedFollowUpHistoryCount =
			ClosureMemory.RecoverySustainedFollowUpSequenceCount;
		Snapshot.RecoverySuppressedBorderlineFollowUpHistoryCount =
			ClosureMemory.RecoverySuppressedBorderlineFollowUpSequenceCount;
		const int32 SustainedFollowUpRecoveryBias = FMath::Clamp(
			ClosureMemory.RecoverySustainedFollowUpSequenceCount,
			0,
			3
		);
		const int32 SuppressedBorderlineFollowUpBias = FMath::Clamp(
			ClosureMemory.RecoverySuppressedBorderlineFollowUpSequenceCount,
			0,
			3
		);
		Snapshot.FollowUpGuidanceContinueBias += SustainedFollowUpRecoveryBias;
		Snapshot.RecommendedGuidanceContinueBias += SuppressedBorderlineFollowUpBias;
		Snapshot.SuppressedPrimaryQueuePressureCount += SustainedFollowUpRecoveryBias;
		Snapshot.SuppressedFollowUpQueuePressureCount += SuppressedBorderlineFollowUpBias;

		if (!ClosureMemory.FocusDeckId.IsEmpty()
			&& (Snapshot.FocusDeckId.IsEmpty()
				|| ClosureMemory.bHasEscalationPressure
				|| ClosureMemory.bHasFollowUpPressure))
		{
			Snapshot.FocusDeckId = ClosureMemory.FocusDeckId;
		}
		if (!ClosureMemory.FocusMethodSegmentId.IsEmpty()
			&& (Snapshot.FocusMethodSegmentId.IsEmpty()
				|| ClosureMemory.bHasEscalationPressure
				|| ClosureMemory.bHasFollowUpPressure))
		{
			Snapshot.FocusMethodSegmentId = ClosureMemory.FocusMethodSegmentId;
		}
		if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
			|| Snapshot.PreferredGuidanceSourceLabel == TEXT("coach-memory-default"))
		{
			if (ClosureMemory.RecoverySustainedFollowUpSequenceCount
				> ClosureMemory.RecoverySuppressedBorderlineFollowUpSequenceCount)
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel = TEXT("coach-memory-closure-follow-up");
			}
			else if (ClosureMemory.RecoverySuppressedBorderlineFollowUpSequenceCount
				> ClosureMemory.RecoverySustainedFollowUpSequenceCount)
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel = TEXT("coach-memory-closure-recommended");
			}
		}
		
		TSet<FString> ArchivedResolvedCaseSet;
		for (const FString& CaseId : ClosureMemory.ArchivedResolvedCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				ArchivedResolvedCaseSet.Add(CaseId);
			}
		}

		TArray<FString> PrioritizedWeakCaseIds;
		const auto AppendUniqueCaseIds = [&PrioritizedWeakCaseIds, &ArchivedResolvedCaseSet](const TArray<FString>& SourceCaseIds)
		{
			for (const FString& CaseId : SourceCaseIds)
			{
				if (!CaseId.IsEmpty()
					&& !ArchivedResolvedCaseSet.Contains(CaseId)
					&& !PrioritizedWeakCaseIds.Contains(CaseId))
				{
					PrioritizedWeakCaseIds.Add(CaseId);
				}
			}
		};

		AppendUniqueCaseIds(ClosureMemory.EscalationCaseIds);
		AppendUniqueCaseIds(ClosureMemory.PersistentWeakCaseIds);
		AppendUniqueCaseIds(Snapshot.WeakCaseIds);
		Snapshot.WeakCaseIds = PrioritizedWeakCaseIds;

		Snapshot.bNeedsCoachIntervention = Snapshot.bNeedsCoachIntervention
			|| ClosureMemory.bHasEscalationPressure
			|| ClosureMemory.bHasFollowUpPressure;
	}
	if (RecommendationHistory.IsStructurallyValid())
	{
		Snapshot.RecurringCoachCaseIds = RecommendationHistory.RecurringCaseIds;
		Snapshot.RepeatRecommendationSequenceCount = RecommendationHistory.RepeatRecommendationSequenceCount;
		Snapshot.DominantCoachSuggestedMode = RecommendationHistory.DominantSuggestedMode;
		Snapshot.DominantCoachSelectionPolicy = RecommendationHistory.DominantSelectionPolicy;
		Snapshot.PreferredGuidanceLane = RecommendationHistory.PreferredGuidanceLane;
		Snapshot.PreferredGuidanceSourceLabel = TEXT("recommendation-history");
		Snapshot.RecommendedGuidancePlanCount = RecommendationHistory.RecommendedLanePlanCount;
		Snapshot.FollowUpGuidancePlanCount = RecommendationHistory.FollowUpLanePlanCount;
		Snapshot.RecommendedGuidanceContinueBias = RecommendationHistory.RecommendedLaneContinueBias;
		Snapshot.FollowUpGuidanceContinueBias = RecommendationHistory.FollowUpLaneContinueBias;
		Snapshot.BroadenedLaunchBudgetHistoryCount = RecommendationHistory.BroadenedLaunchPlanCount;
		Snapshot.TightenedLaunchBudgetHistoryCount = RecommendationHistory.TightenedLaunchPlanCount;
		Snapshot.DeferredTightenedLaunchHistoryCount =
			RecommendationHistory.DeferredTightenedLaunchPlanCount;
		Snapshot.DeferredLaunchHistoryCaseCount = RecommendationHistory.DeferredLaunchCaseCount;
		Snapshot.DeferredFirstFollowUpPacketHistoryCount =
			RecommendationHistory.DeferredFirstFollowUpPacketPlanCount;
		Snapshot.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount =
			RecommendationHistory
				.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount;
		Snapshot.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount =
			RecommendationHistory
				.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount;
		Snapshot.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore =
			RecommendationHistory
				.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore;
		Snapshot.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore =
			RecommendationHistory
				.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore;
		Snapshot.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount =
			RecommendationHistory.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount;
		Snapshot.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount =
			RecommendationHistory.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount;
		Snapshot.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore =
			RecommendationHistory.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore;
		Snapshot.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore =
			RecommendationHistory.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore;
		Snapshot.AlignedTightFollowUpPacketStructureOutcomeHistoryCount =
			RecommendationHistory.AlignedTightFollowUpPacketStructureOutcomeHistoryCount;
		Snapshot.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount =
			RecommendationHistory.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount;
		Snapshot.AlignedTightFollowUpPacketStructureOutcomeAverageScore =
			RecommendationHistory.AlignedTightFollowUpPacketStructureOutcomeAverageScore;
		Snapshot.AlignedBroadRecommendedPacketStructureOutcomeAverageScore =
			RecommendationHistory.AlignedBroadRecommendedPacketStructureOutcomeAverageScore;
		Snapshot.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount;
		Snapshot.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount;
		Snapshot.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore;
		Snapshot.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAverageScore;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAverageScore;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount;
		Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAverageScore;
		Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAverageScore =
			RecommendationHistory.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAverageScore;
		Snapshot.bHasRepeatRecommendationPressure = RecommendationHistory.bHasRepeatRecommendationPressure;
		const int32 DeferredTightenedLaunchBias = FMath::Clamp(
			RecommendationHistory.DeferredTightenedLaunchPlanCount,
			0,
			3
		);
		Snapshot.FollowUpGuidanceContinueBias += DeferredTightenedLaunchBias;
		Snapshot.SuppressedPrimaryQueuePressureCount += DeferredTightenedLaunchBias;
		if (RecommendationHistory.BroadenedLaunchPlanCount >= 2
			&& RecommendationHistory.BroadenedLaunchAverageOutcomeScore
				>= RecommendationHistory.TightenedLaunchAverageOutcomeScore + 5.0f)
		{
			Snapshot.PreferredLaunchBudgetBias = 1;
			Snapshot.PreferredLaunchBudgetSourceLabel = TEXT("recommendation-history-broadened-launch");
		}
		else if (RecommendationHistory.TightenedLaunchPlanCount >= 2
			&& RecommendationHistory.TightenedLaunchAverageOutcomeScore
				>= RecommendationHistory.BroadenedLaunchAverageOutcomeScore + 5.0f)
		{
			Snapshot.PreferredLaunchBudgetBias = -1;
			Snapshot.PreferredLaunchBudgetSourceLabel = TEXT("recommendation-history-tightened-launch");
		}
		if (RecommendationHistory.DeferredTightenedLaunchPlanCount >= 2
			&& RecommendationHistory.DeferredTightenedLaunchAverageOutcomeScore
				>= RecommendationHistory.TightenedLaunchAverageOutcomeScore - 3.0f)
		{
			Snapshot.PreferredLaunchBudgetBias = -1;
			Snapshot.PreferredLaunchBudgetSourceLabel =
				TEXT("recommendation-history-deferred-tightened-launch");
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel == TEXT("recommendation-history"))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-deferred-tightened-launch");
			}
		}
		if (RecommendationHistory.DeferredFirstFollowUpPacketPlanCount >= 2
			&& RecommendationHistory.DeferredFirstFollowUpPacketAverageOutcomeScore
				>= RecommendationHistory.DeferredTightenedLaunchAverageOutcomeScore - 3.0f)
		{
			const int32 DeferredFirstPacketBias = FMath::Clamp(
				RecommendationHistory.DeferredFirstFollowUpPacketPlanCount,
				0,
				3
			);
			Snapshot.FollowUpGuidanceContinueBias += DeferredFirstPacketBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(1, DeferredFirstPacketBias - 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-deferred-first-follow-up");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-deferred-first-follow-up");
			}
		}
		const bool bReliableAlignedTrustedTightPlanOutcomeHistory =
			RecommendationHistory
					.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount
				>= 2
			&& RecommendationHistory
					.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore
				>= 60.0f
			&& (RecommendationHistory
						.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount
					<= 0
				|| RecommendationHistory
						.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore
					>= RecommendationHistory
							.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore
						- 2.0f);
		const bool bReliableAlignedTrustedBroadPlanOutcomeHistory =
			RecommendationHistory
					.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount
				>= 2
			&& RecommendationHistory
					.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore
				>= 58.0f
			&& (RecommendationHistory
						.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount
					<= 0
				|| RecommendationHistory
						.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore
					>= RecommendationHistory
							.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore
						- 2.0f);
		if (bReliableAlignedTrustedTightPlanOutcomeHistory)
		{
			const int32 ReliableAlignedTrustedTightPlanOutcomeBias = FMath::Clamp(
				RecommendationHistory
						.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount
					- RecommendationHistory
							.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount
					+ (RecommendationHistory
								.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore
							>= 80.0f
						? 1
						: 0),
				1,
				4
			);
			Snapshot.FollowUpGuidanceContinueBias += ReliableAlignedTrustedTightPlanOutcomeBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				ReliableAlignedTrustedTightPlanOutcomeBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind
					== EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-outcome");
			}
		}
		else if (bReliableAlignedTrustedBroadPlanOutcomeHistory)
		{
			const int32 ReliableAlignedTrustedBroadPlanOutcomeBias = FMath::Clamp(
				RecommendationHistory
						.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount
					- RecommendationHistory
							.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount
					+ (RecommendationHistory
								.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore
							>= 78.0f
						? 1
						: 0),
				1,
				4
			);
			Snapshot.RecommendedGuidanceContinueBias += ReliableAlignedTrustedBroadPlanOutcomeBias;
			Snapshot.SuppressedFollowUpQueuePressureCount += ReliableAlignedTrustedBroadPlanOutcomeBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-outcome");
			}
		}
		const int32 ReliableAlignedTrustedTightFollowUpGuidanceOutcomeBias =
			(RecommendationHistory.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount >= 2
				&& RecommendationHistory.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore >= 60.0f)
				? FMath::Clamp(
					RecommendationHistory.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount
						- RecommendationHistory.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount
						+ (RecommendationHistory
								 .ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore
							 >= 80.0f
							? 1
							: 0),
					1,
					4)
				: 0;
		const int32 ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeBias =
			(RecommendationHistory.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount >= 2
				&& RecommendationHistory
						.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore
					>= 58.0f)
				? FMath::Clamp(
					RecommendationHistory.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount
						- RecommendationHistory.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount
						+ (RecommendationHistory
								 .ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore
							 >= 78.0f
							? 1
							: 0),
					1,
					4)
				: 0;
		if (ReliableAlignedTrustedTightFollowUpGuidanceOutcomeBias
			> ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeBias)
		{
			Snapshot.FollowUpGuidanceContinueBias += ReliableAlignedTrustedTightFollowUpGuidanceOutcomeBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				ReliableAlignedTrustedTightFollowUpGuidanceOutcomeBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-aligned-tight-follow-up-outcome");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-aligned-tight-follow-up-outcome");
			}
		}
		else if (ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeBias
			> ReliableAlignedTrustedTightFollowUpGuidanceOutcomeBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-aligned-broad-recommended-outcome");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(
					TEXT("coach-memory-method-drill-recovery-structure-plan")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-aligned-broad-recommended-outcome");
			}
		}
		const int32 AlignedTightPacketStructureOutcomeBias =
			(RecommendationHistory.AlignedTightFollowUpPacketStructureOutcomeHistoryCount >= 2
				&& RecommendationHistory.AlignedTightFollowUpPacketStructureOutcomeAverageScore
					>= 60.0f)
				? FMath::Clamp(
					RecommendationHistory.AlignedTightFollowUpPacketStructureOutcomeHistoryCount
						- RecommendationHistory.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount
						+ (RecommendationHistory.AlignedTightFollowUpPacketStructureOutcomeAverageScore
							 >= 78.0f
							? 1
							: 0),
					1,
					4)
				: 0;
		const int32 AlignedBroadPacketStructureOutcomeBias =
			(RecommendationHistory.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount >= 2
				&& RecommendationHistory.AlignedBroadRecommendedPacketStructureOutcomeAverageScore
					>= 58.0f)
				? FMath::Clamp(
					RecommendationHistory.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount
						- RecommendationHistory.AlignedTightFollowUpPacketStructureOutcomeHistoryCount
						+ (RecommendationHistory.AlignedBroadRecommendedPacketStructureOutcomeAverageScore
							 >= 76.0f
							? 1
							: 0),
					1,
					4)
				: 0;
		if (AlignedTightPacketStructureOutcomeBias > AlignedBroadPacketStructureOutcomeBias)
		{
			Snapshot.FollowUpGuidanceContinueBias += AlignedTightPacketStructureOutcomeBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AlignedTightPacketStructureOutcomeBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-tight-follow-up");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-tight-follow-up");
			}
		}
		else if (AlignedBroadPacketStructureOutcomeBias > AlignedTightPacketStructureOutcomeBias)
		{
			Snapshot.RecommendedGuidanceContinueBias += AlignedBroadPacketStructureOutcomeBias;
			Snapshot.SuppressedFollowUpQueuePressureCount += AlignedBroadPacketStructureOutcomeBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-broad-recommended");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-broad-recommended");
			}
		}
		const int32 AcceptedAlignedTightPacketOutcomeBias =
			(RecommendationHistory.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount >= 2
				&& RecommendationHistory.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore
					>= 60.0f)
				? FMath::Clamp(
					RecommendationHistory.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
						- RecommendationHistory.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
						+ (RecommendationHistory.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore
							 >= 80.0f
							? 1
							: 0),
					1,
					4)
				: 0;
		const int32 AcceptedAlignedBroadPacketOutcomeBias =
			(RecommendationHistory.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount >= 2
				&& RecommendationHistory.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore
					>= 58.0f)
				? FMath::Clamp(
					RecommendationHistory.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
						- RecommendationHistory.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
						+ (RecommendationHistory.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore
							 >= 78.0f
							? 1
							: 0),
					1,
					4)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableBias =
			(RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
					>= 2
				&& RecommendationHistory.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore
					>= 70.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore
							   >= 86.0f
							? 1
							: 0),
					1,
					6)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore
					>= 68.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore
							   >= 84.0f
							? 1
							: 0),
					1,
					6)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAverageScore
					>= 72.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAverageScore
							   >= 88.0f
							? 1
							: 0),
					1,
					7)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAverageScore
					>= 70.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAverageScore
							   >= 86.0f
							? 1
							: 0),
					1,
					7)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
					>= 74.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
							   >= 89.0f
							? 1
							: 0),
					1,
					8)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
					>= 72.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
							   >= 87.0f
							? 1
							: 0),
					1,
					8)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
					>= 76.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
							   >= 90.0f
							? 1
							: 0),
					1,
					9)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
					>= 74.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
							   >= 88.0f
							? 1
							: 0),
					1,
					9)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
					>= 78.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
							   >= 92.0f
							? 1
							: 0),
					1,
					10)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
					>= 76.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
							   >= 90.0f
							? 1
							: 0),
					1,
					10)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
					>= 80.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
							   >= 94.0f
							? 1
							: 0),
					1,
					11)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
					>= 78.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
							   >= 92.0f
							? 1
							: 0),
					1,
					11)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 82.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 96.0f
							? 1
							: 0),
					1,
					12)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 80.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 94.0f
							? 1
							: 0),
					1,
					12)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 84.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 98.0f
							? 1
							: 0),
					1,
					13)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 82.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 96.0f
							? 1
							: 0),
					1,
					13)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 86.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					14)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 84.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 98.0f
							? 1
							: 0),
					1,
					14)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 88.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					15)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 86.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					15)
				: 0;
		const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					16)
				: 0;
		const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 88.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					16)
				: 0;
		const int32 AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierTightBias =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 94.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierBroadBias =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 94.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 94.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 94.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 94.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 94.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 94.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					18)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					17)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					16)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 88.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					16)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 92.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					15)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
			(RecommendationHistory
					 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					15)
				: 0;
		const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
			(RecommendationHistory
					 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						>= 2
				&& RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 90.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
					1,
					14)
				: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
					>= 88.0f)
				? FMath::Clamp(
					RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						- RecommendationHistory
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
						+ (RecommendationHistory
								   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
							   >= 100.0f
							? 1
							: 0),
				1,
				14)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 92.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 90.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 94.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				12)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 92.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				12)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 94.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 98.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 94.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 98.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 94.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 98.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 94.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 98.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 TopAcceptedAlignedTightPacketCompletionReliabilitySignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 TopAcceptedAlignedBroadPacketCompletionReliabilitySignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 94.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 98.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 94.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 98.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSignal =
		(RecommendationHistory
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& RecommendationHistory
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 96.0f)
			? FMath::Clamp(
				RecommendationHistory
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- RecommendationHistory
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (RecommendationHistory
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	if (AcceptedAlignedTightPacketOutcomeBias > AcceptedAlignedBroadPacketOutcomeBias)
	{
		Snapshot.FollowUpGuidanceContinueBias += AcceptedAlignedTightPacketOutcomeBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketOutcomeBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-outcome");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-outcome");
			}
		}
		else if (AcceptedAlignedBroadPacketOutcomeBias > AcceptedAlignedTightPacketOutcomeBias)
		{
			Snapshot.RecommendedGuidanceContinueBias += AcceptedAlignedBroadPacketOutcomeBias;
			Snapshot.SuppressedFollowUpQueuePressureCount += AcceptedAlignedBroadPacketOutcomeBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-outcome");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-outcome");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias
			> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeBias
			> AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeBias - 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeBias
			> AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierTightBias
			> HighestExactCompletionReliabilityOutcomeTierBroadBias)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierTightBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierTightBias - 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (HighestExactCompletionReliabilityOutcomeTierBroadBias
			> HighestExactCompletionReliabilityOutcomeTierTightBias)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierBroadBias;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierBroadBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSignal - 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}

		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}

		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable");
			}
		}

		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
					- 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		else if (
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		if (TopAcceptedAlignedTightPacketCompletionReliabilitySignal
			> TopAcceptedAlignedBroadPacketCompletionReliabilitySignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				TopAcceptedAlignedTightPacketCompletionReliabilitySignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				TopAcceptedAlignedTightPacketCompletionReliabilitySignal - 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		else if (
			TopAcceptedAlignedBroadPacketCompletionReliabilitySignal
			> TopAcceptedAlignedTightPacketCompletionReliabilitySignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				TopAcceptedAlignedBroadPacketCompletionReliabilitySignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				TopAcceptedAlignedBroadPacketCompletionReliabilitySignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		if (TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSignal
			> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSignal - 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		else if (
			TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSignal
			> TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		if (TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSignal
			> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSignal - 1);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		else if (
			TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSignal
			> TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSignal;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredGuidanceSourceLabel))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable")
						TEXT("-reliable");
			}
		}
		if (TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSignal
			> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSignal)
		{
			Snapshot.FollowUpGuidanceContinueBias +=
				TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSignal - 1);
		}
		else if (
			TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSignal
			> TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSignal)
		{
			Snapshot.RecommendedGuidanceContinueBias +=
				TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSignal;
			Snapshot.SuppressedFollowUpQueuePressureCount +=
				TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSignal;
		}

		if (!RecommendationHistory.FocusDeckId.IsEmpty()
			&& (Snapshot.FocusDeckId.IsEmpty()
				|| RecommendationHistory.bShouldBiasCoachReviewed))
		{
			Snapshot.FocusDeckId = RecommendationHistory.FocusDeckId;
		}
		if (!RecommendationHistory.FocusMethodSegmentId.IsEmpty()
			&& (Snapshot.FocusMethodSegmentId.IsEmpty()
				|| RecommendationHistory.bShouldBiasCoachReviewed))
		{
			Snapshot.FocusMethodSegmentId = RecommendationHistory.FocusMethodSegmentId;
		}

		TSet<FString> ArchivedResolvedCaseSet;
		for (const FString& CaseId : Snapshot.ArchivedResolvedCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				ArchivedResolvedCaseSet.Add(CaseId);
			}
		}

		TArray<FString> ExistingWeakCaseIds = Snapshot.WeakCaseIds;
		TArray<FString> PrioritizedWeakCaseIds;
		const auto AppendUniqueRecurringCases = [&PrioritizedWeakCaseIds, &ArchivedResolvedCaseSet](const TArray<FString>& SourceCaseIds)
		{
			for (const FString& CaseId : SourceCaseIds)
			{
				if (!CaseId.IsEmpty()
					&& !ArchivedResolvedCaseSet.Contains(CaseId)
					&& !PrioritizedWeakCaseIds.Contains(CaseId))
				{
					PrioritizedWeakCaseIds.Add(CaseId);
				}
			}
		};

		AppendUniqueRecurringCases(RecommendationHistory.RecurringCaseIds);
		AppendUniqueRecurringCases(ExistingWeakCaseIds);
		Snapshot.WeakCaseIds = PrioritizedWeakCaseIds;

		Snapshot.bNeedsCoachIntervention = Snapshot.bNeedsCoachIntervention
			|| RecommendationHistory.bHasRepeatRecommendationPressure;
	}

	TArray<FHyperTwistTrainingRunRecord> MethodDrillFollowUpRunRecords;
	MethodDrillFollowUpRunRecords.Reserve(RepositoryState.RunRecords.Num());
	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (!RunRecord.IsStructurallyValid()
			|| RunRecord.Session.UserId != UserId
			|| !HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillFollowUpTrainingSessionId(
				RunRecord.Session.TrainingSessionId))
		{
			continue;
		}

		MethodDrillFollowUpRunRecords.Add(RunRecord);
	}

	if (MethodDrillFollowUpRunRecords.Num() > 0)
	{
		MethodDrillFollowUpRunRecords =
			HyperTwistTrainingRepositoryLibraryInternal::SortRunRecordsByUpdateUtc(
				MethodDrillFollowUpRunRecords);
		const int32 FirstRelevantIndex = FMath::Max(0, MethodDrillFollowUpRunRecords.Num() - 8);
		float MethodDrillOutcomeAccumulator = 0.0f;
		float NarrowMethodDrillPacketOutcomeAccumulator = 0.0f;
		float BroadMethodDrillPacketOutcomeAccumulator = 0.0f;
		for (int32 Index = FirstRelevantIndex; Index < MethodDrillFollowUpRunRecords.Num(); ++Index)
		{
			const FHyperTwistTrainingRunRecord& RunRecord = MethodDrillFollowUpRunRecords[Index];
			const float OutcomeScore =
				HyperTwistTrainingRepositoryLibraryInternal::ResolveMethodDrillFollowUpOutcomeScore(
					RunRecord);
			Snapshot.MethodDrillFollowUpHistoryCount += 1;
			MethodDrillOutcomeAccumulator += OutcomeScore;
			if (HyperTwistTrainingRepositoryLibraryInternal::IsNarrowMethodDrillFollowUpPacketStructureSessionId(
					RunRecord.Session.TrainingSessionId))
			{
				Snapshot.NarrowMethodDrillFollowUpPacketStructureHistoryCount += 1;
				NarrowMethodDrillPacketOutcomeAccumulator += OutcomeScore;
			}
			else if (HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillFollowUpPacketStructureSessionId(
					RunRecord.Session.TrainingSessionId))
			{
				Snapshot.BroadMethodDrillFollowUpPacketStructureHistoryCount += 1;
				BroadMethodDrillPacketOutcomeAccumulator += OutcomeScore;
			}
			if (OutcomeScore >= 70.0f)
			{
				Snapshot.StrongMethodDrillFollowUpHistoryCount += 1;
			}
			else if (OutcomeScore <= 45.0f)
			{
				Snapshot.WeakMethodDrillFollowUpHistoryCount += 1;
			}
		}

		if (Snapshot.MethodDrillFollowUpHistoryCount > 0)
		{
			Snapshot.MethodDrillFollowUpAverageOutcomeScore =
				MethodDrillOutcomeAccumulator
				/ static_cast<float>(Snapshot.MethodDrillFollowUpHistoryCount);
		}
		if (Snapshot.NarrowMethodDrillFollowUpPacketStructureHistoryCount > 0)
		{
			Snapshot.NarrowMethodDrillFollowUpPacketStructureAverageOutcomeScore =
				NarrowMethodDrillPacketOutcomeAccumulator
				/ static_cast<float>(Snapshot.NarrowMethodDrillFollowUpPacketStructureHistoryCount);
		}
		if (Snapshot.BroadMethodDrillFollowUpPacketStructureHistoryCount > 0)
		{
			Snapshot.BroadMethodDrillFollowUpPacketStructureAverageOutcomeScore =
				BroadMethodDrillPacketOutcomeAccumulator
				/ static_cast<float>(Snapshot.BroadMethodDrillFollowUpPacketStructureHistoryCount);
		}

		const bool bStrongMethodDrillHistory =
			Snapshot.MethodDrillFollowUpHistoryCount >= 2
			&& Snapshot.StrongMethodDrillFollowUpHistoryCount
				>= Snapshot.WeakMethodDrillFollowUpHistoryCount
			&& Snapshot.MethodDrillFollowUpAverageOutcomeScore >= 60.0f;
		const bool bWeakMethodDrillHistory =
			Snapshot.MethodDrillFollowUpHistoryCount >= 2
			&& Snapshot.WeakMethodDrillFollowUpHistoryCount
				> Snapshot.StrongMethodDrillFollowUpHistoryCount
			&& Snapshot.MethodDrillFollowUpAverageOutcomeScore <= 50.0f;
		if (bStrongMethodDrillHistory)
		{
			const int32 MethodDrillFollowUpBias = FMath::Clamp(
				Snapshot.StrongMethodDrillFollowUpHistoryCount
					- Snapshot.WeakMethodDrillFollowUpHistoryCount
					+ (Snapshot.MethodDrillFollowUpAverageOutcomeScore >= 75.0f ? 1 : 0),
				1,
				3
			);
			Snapshot.FollowUpGuidanceContinueBias += MethodDrillFollowUpBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				MethodDrillFollowUpBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-method-drill-follow-up-strong");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-method-drill-follow-up-strong");
			}
		}
		const bool bNarrowMethodDrillPacketStructureHistory =
			Snapshot.NarrowMethodDrillFollowUpPacketStructureHistoryCount >= 2
			&& Snapshot.NarrowMethodDrillFollowUpPacketStructureAverageOutcomeScore >= 60.0f
			&& (Snapshot.BroadMethodDrillFollowUpPacketStructureHistoryCount <= 0
				|| Snapshot.NarrowMethodDrillFollowUpPacketStructureAverageOutcomeScore
					>= Snapshot.BroadMethodDrillFollowUpPacketStructureAverageOutcomeScore);
		const bool bBroadMethodDrillPacketStructureHistory =
			Snapshot.BroadMethodDrillFollowUpPacketStructureHistoryCount >= 2
			&& Snapshot.BroadMethodDrillFollowUpPacketStructureAverageOutcomeScore >= 58.0f
			&& (Snapshot.NarrowMethodDrillFollowUpPacketStructureHistoryCount <= 0
				|| Snapshot.BroadMethodDrillFollowUpPacketStructureAverageOutcomeScore
					>= Snapshot.NarrowMethodDrillFollowUpPacketStructureAverageOutcomeScore);
		if (bNarrowMethodDrillPacketStructureHistory)
		{
			const int32 NarrowPacketStructureBias = FMath::Clamp(
				Snapshot.NarrowMethodDrillFollowUpPacketStructureHistoryCount
					- Snapshot.BroadMethodDrillFollowUpPacketStructureHistoryCount
					+ (Snapshot.NarrowMethodDrillFollowUpPacketStructureAverageOutcomeScore >= 75.0f
						? 1
						: 0),
				1,
				3
			);
			Snapshot.FollowUpGuidanceContinueBias += NarrowPacketStructureBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				NarrowPacketStructureBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-method-drill-follow-up-packet-structure-narrow");
			}
		}
		else if (bBroadMethodDrillPacketStructureHistory)
		{
			const int32 BroadPacketStructureBias = FMath::Clamp(
				Snapshot.BroadMethodDrillFollowUpPacketStructureHistoryCount
					- Snapshot.NarrowMethodDrillFollowUpPacketStructureHistoryCount
					+ (Snapshot.BroadMethodDrillFollowUpPacketStructureAverageOutcomeScore >= 72.0f
						? 1
						: 0),
				1,
				3
			);
			Snapshot.RecommendedGuidanceContinueBias += BroadPacketStructureBias;
			Snapshot.SuppressedFollowUpQueuePressureCount += BroadPacketStructureBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
			{
				Snapshot.PreferredGuidanceLane =
					EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-method-drill-follow-up-packet-structure-broad");
			}
		}
		else if (bWeakMethodDrillHistory)
		{
			const int32 MethodDrillRedirectBias = FMath::Clamp(
				Snapshot.WeakMethodDrillFollowUpHistoryCount
					- Snapshot.StrongMethodDrillFollowUpHistoryCount,
				1,
				2
			);
			Snapshot.RecommendedGuidanceContinueBias += MethodDrillRedirectBias;
			Snapshot.SuppressedFollowUpQueuePressureCount += MethodDrillRedirectBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-method-drill-follow-up-weak");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-method-drill-follow-up-weak");
			}
		}
	}
	if (CarryForwardPolicy.IsStructurallyValid())
	{
		Snapshot.SuppressedResolvedCoachCaseIds = CarryForwardPolicy.SuppressedResolvedCaseIds;
		Snapshot.PinnedCarryForwardCaseIds = CarryForwardPolicy.PinnedCarryForwardCaseIds;
		Snapshot.DominantCoachSuggestedMode = CarryForwardPolicy.DominantSuggestedMode;
		Snapshot.DominantCoachSelectionPolicy = CarryForwardPolicy.DominantSelectionPolicy;
		Snapshot.bHasPinnedCarryForwardPressure = CarryForwardPolicy.bPinRecurringCases
			|| CarryForwardPolicy.bNeedsEscalationHandOff;

		if (!CarryForwardPolicy.FocusDeckId.IsEmpty()
			&& (Snapshot.FocusDeckId.IsEmpty()
				|| CarryForwardPolicy.bNeedsEscalationHandOff
				|| CarryForwardPolicy.bBiasCoachReviewed))
		{
			Snapshot.FocusDeckId = CarryForwardPolicy.FocusDeckId;
		}
		if (!CarryForwardPolicy.FocusMethodSegmentId.IsEmpty()
			&& (Snapshot.FocusMethodSegmentId.IsEmpty()
				|| CarryForwardPolicy.bNeedsEscalationHandOff
				|| CarryForwardPolicy.bBiasCoachReviewed))
		{
			Snapshot.FocusMethodSegmentId = CarryForwardPolicy.FocusMethodSegmentId;
		}

		TSet<FString> SuppressedResolvedCaseSet;
		for (const FString& CaseId : CarryForwardPolicy.SuppressedResolvedCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				SuppressedResolvedCaseSet.Add(CaseId);
			}
		}

		TArray<FString> PrioritizedWeakCaseIds;
		const auto AppendPolicyCaseIds = [&PrioritizedWeakCaseIds, &SuppressedResolvedCaseSet](const TArray<FString>& SourceCaseIds)
		{
			for (const FString& CaseId : SourceCaseIds)
			{
				if (!CaseId.IsEmpty()
					&& !SuppressedResolvedCaseSet.Contains(CaseId)
					&& !PrioritizedWeakCaseIds.Contains(CaseId))
				{
					PrioritizedWeakCaseIds.Add(CaseId);
				}
			}
		};

		AppendPolicyCaseIds(CarryForwardPolicy.EscalationCarryForwardCaseIds);
		AppendPolicyCaseIds(CarryForwardPolicy.PinnedCarryForwardCaseIds);
		AppendPolicyCaseIds(Snapshot.WeakCaseIds);
		Snapshot.WeakCaseIds = PrioritizedWeakCaseIds;

		Snapshot.bNeedsCoachIntervention = Snapshot.bNeedsCoachIntervention
			|| CarryForwardPolicy.bHasActiveCarryForwardPressure
			|| CarryForwardPolicy.bNeedsEscalationHandOff;
	}
	if (ArchivePolicy.IsStructurallyValid())
	{
		Snapshot.LongTermArchivedCoachCaseIds = ArchivePolicy.LongTermArchivedCaseIds;
		Snapshot.ExpiredCarryForwardCaseIds = ArchivePolicy.ExpiredCarryForwardCaseIds;
		Snapshot.StableArchivedCoachCaseIds = ArchivePolicy.StableLongTermArchivedCaseIds;
		Snapshot.ProvisionalArchivedCoachCaseIds = ArchivePolicy.ProvisionalArchivedCaseIds;
		Snapshot.ArchiveReopenRiskCaseIds = ArchivePolicy.ReopenRiskArchivedCaseIds;
		Snapshot.ArchivedResolvedCaseIds = ArchivePolicy.LongTermArchivedCaseIds;
		Snapshot.SuppressedResolvedCoachCaseIds = ArchivePolicy.LongTermArchivedCaseIds;
		Snapshot.PinnedCarryForwardCaseIds = ArchivePolicy.RetainedCarryForwardCaseIds;
		Snapshot.DominantCoachSuggestedMode = ArchivePolicy.DominantSuggestedMode;
		Snapshot.DominantCoachSelectionPolicy = ArchivePolicy.DominantSelectionPolicy;
		Snapshot.ArchiveStabilityScore = ArchivePolicy.ArchiveStabilityScore;
		Snapshot.ArchiveRetentionTuningScore = ArchivePolicy.ArchiveRetentionTuningScore;
		Snapshot.bHasStableArchiveMemory = ArchivePolicy.bHasStableArchiveMemory;
		Snapshot.bNeedsArchiveRetentionTuning = ArchivePolicy.bNeedsArchiveRetentionTuning;
		Snapshot.bHasPinnedCarryForwardPressure = ArchivePolicy.RetainedCarryForwardCaseCount > 0
			|| ArchivePolicy.bShouldRetainEscalationCarryForward;

		if (!ArchivePolicy.FocusDeckId.IsEmpty()
			&& (Snapshot.FocusDeckId.IsEmpty() || ArchivePolicy.bHasActiveArchivePressure))
		{
			Snapshot.FocusDeckId = ArchivePolicy.FocusDeckId;
		}
		if (!ArchivePolicy.FocusMethodSegmentId.IsEmpty()
			&& (Snapshot.FocusMethodSegmentId.IsEmpty() || ArchivePolicy.bHasActiveArchivePressure))
		{
			Snapshot.FocusMethodSegmentId = ArchivePolicy.FocusMethodSegmentId;
		}

		TSet<FString> LongTermArchivedCaseSet;
		for (const FString& CaseId : ArchivePolicy.LongTermArchivedCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				LongTermArchivedCaseSet.Add(CaseId);
			}
		}

		TArray<FString> FilteredRecurringCaseIds;
		for (const FString& CaseId : Snapshot.RecurringCoachCaseIds)
		{
			if (!CaseId.IsEmpty() && !LongTermArchivedCaseSet.Contains(CaseId))
			{
				FilteredRecurringCaseIds.AddUnique(CaseId);
			}
		}
		Snapshot.RecurringCoachCaseIds = FilteredRecurringCaseIds;
		Snapshot.bHasRepeatRecommendationPressure = Snapshot.bHasRepeatRecommendationPressure
			&& Snapshot.RecurringCoachCaseIds.Num() > 0;

		TArray<FString> PrioritizedWeakCaseIds;
		const auto AppendArchivePolicyCaseIds = [&PrioritizedWeakCaseIds, &LongTermArchivedCaseSet](
			const TArray<FString>& SourceCaseIds)
		{
			for (const FString& CaseId : SourceCaseIds)
			{
				if (!CaseId.IsEmpty()
					&& !LongTermArchivedCaseSet.Contains(CaseId)
					&& !PrioritizedWeakCaseIds.Contains(CaseId))
				{
					PrioritizedWeakCaseIds.Add(CaseId);
				}
			}
		};

		AppendArchivePolicyCaseIds(ArchivePolicy.EscalationRetainedCaseIds);
		AppendArchivePolicyCaseIds(ArchivePolicy.RetainedCarryForwardCaseIds);
		AppendArchivePolicyCaseIds(Snapshot.WeakCaseIds);
		Snapshot.WeakCaseIds = PrioritizedWeakCaseIds;

		Snapshot.bNeedsCoachIntervention = Snapshot.bNeedsCoachIntervention
			|| ArchivePolicy.bHasActiveArchivePressure
			|| ArchivePolicy.bNeedsArchiveRetentionTuning;
	}

	TArray<FHyperTwistTrainingRunRecord> AlignedCoachFollowUpRunRecords;
	AlignedCoachFollowUpRunRecords.Reserve(RepositoryState.RunRecords.Num());
	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (!RunRecord.IsStructurallyValid()
			|| RunRecord.Session.UserId != UserId
			|| !HyperTwistTrainingRepositoryLibraryInternal::IsCoachFollowUpTrainingSessionId(
				RunRecord.Session.TrainingSessionId))
		{
			continue;
		}

		if (!HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightCoachFollowUpPacketStructureSessionId(
				RunRecord.Session.TrainingSessionId)
			&& !HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadCoachFollowUpPacketStructureSessionId(
				RunRecord.Session.TrainingSessionId))
		{
			continue;
		}

		AlignedCoachFollowUpRunRecords.Add(RunRecord);
	}

	if (AlignedCoachFollowUpRunRecords.Num() > 0)
	{
		AlignedCoachFollowUpRunRecords =
			HyperTwistTrainingRepositoryLibraryInternal::SortRunRecordsByUpdateUtc(
				AlignedCoachFollowUpRunRecords);
		const int32 FirstRelevantIndex = FMath::Max(0, AlignedCoachFollowUpRunRecords.Num() - 8);
		float AlignedTightOutcomeAccumulator = 0.0f;
		float AlignedBroadOutcomeAccumulator = 0.0f;
		for (int32 Index = FirstRelevantIndex; Index < AlignedCoachFollowUpRunRecords.Num(); ++Index)
		{
			const FHyperTwistTrainingRunRecord& RunRecord = AlignedCoachFollowUpRunRecords[Index];
			const float OutcomeScore =
				HyperTwistTrainingRepositoryLibraryInternal::ResolveCoachFollowUpOutcomeScore(
					RunRecord);
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightCoachFollowUpPacketStructureSessionId(
					RunRecord.Session.TrainingSessionId))
			{
				Snapshot.AlignedTightFollowUpPacketStructureHistoryCount += 1;
				AlignedTightOutcomeAccumulator += OutcomeScore;
			}
			else if (HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadCoachFollowUpPacketStructureSessionId(
					RunRecord.Session.TrainingSessionId))
			{
				Snapshot.AlignedBroadRecommendedPacketStructureHistoryCount += 1;
				AlignedBroadOutcomeAccumulator += OutcomeScore;
			}
		}

		if (Snapshot.AlignedTightFollowUpPacketStructureHistoryCount > 0)
		{
			Snapshot.AlignedTightFollowUpPacketStructureAverageOutcomeScore =
				AlignedTightOutcomeAccumulator
				/ static_cast<float>(Snapshot.AlignedTightFollowUpPacketStructureHistoryCount);
		}
		if (Snapshot.AlignedBroadRecommendedPacketStructureHistoryCount > 0)
		{
			Snapshot.AlignedBroadRecommendedPacketStructureAverageOutcomeScore =
				AlignedBroadOutcomeAccumulator
				/ static_cast<float>(Snapshot.AlignedBroadRecommendedPacketStructureHistoryCount);
		}

		const bool bAlignedTightPacketStructureHistory =
			Snapshot.AlignedTightFollowUpPacketStructureHistoryCount >= 2
			&& Snapshot.AlignedTightFollowUpPacketStructureAverageOutcomeScore >= 60.0f
			&& (Snapshot.AlignedBroadRecommendedPacketStructureHistoryCount <= 0
				|| Snapshot.AlignedTightFollowUpPacketStructureAverageOutcomeScore
					>= Snapshot.AlignedBroadRecommendedPacketStructureAverageOutcomeScore - 2.0f);
		const bool bAlignedBroadPacketStructureHistory =
			Snapshot.AlignedBroadRecommendedPacketStructureHistoryCount >= 2
			&& Snapshot.AlignedBroadRecommendedPacketStructureAverageOutcomeScore >= 58.0f
			&& (Snapshot.AlignedTightFollowUpPacketStructureHistoryCount <= 0
				|| Snapshot.AlignedBroadRecommendedPacketStructureAverageOutcomeScore
					>= Snapshot.AlignedTightFollowUpPacketStructureAverageOutcomeScore - 2.0f);
		if (bAlignedTightPacketStructureHistory
			&& (!bAlignedBroadPacketStructureHistory
				|| Snapshot.AlignedTightFollowUpPacketStructureAverageOutcomeScore
					>= Snapshot.AlignedBroadRecommendedPacketStructureAverageOutcomeScore))
		{
			const int32 AlignedTightPacketStructureBias = FMath::Clamp(
				Snapshot.AlignedTightFollowUpPacketStructureHistoryCount
					- Snapshot.AlignedBroadRecommendedPacketStructureHistoryCount
					+ (Snapshot.AlignedTightFollowUpPacketStructureAverageOutcomeScore >= 78.0f
						? 1
						: 0),
				1,
				4
			);
			Snapshot.FollowUpGuidanceContinueBias += AlignedTightPacketStructureBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
				1,
				AlignedTightPacketStructureBias - 1
			);
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(
					TEXT("coach-memory-aligned-follow-up-packet-structure")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-tight-follow-up");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(
					TEXT("coach-memory-aligned-follow-up-packet-structure")))
			{
				Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-tight-follow-up");
			}
		}
		else if (bAlignedBroadPacketStructureHistory)
		{
			const int32 AlignedBroadPacketStructureBias = FMath::Clamp(
				Snapshot.AlignedBroadRecommendedPacketStructureHistoryCount
					- Snapshot.AlignedTightFollowUpPacketStructureHistoryCount
					+ (Snapshot.AlignedBroadRecommendedPacketStructureAverageOutcomeScore >= 76.0f
						? 1
						: 0),
				1,
				4
			);
			Snapshot.RecommendedGuidanceContinueBias += AlignedBroadPacketStructureBias;
			Snapshot.SuppressedFollowUpQueuePressureCount += AlignedBroadPacketStructureBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(
					TEXT("coach-memory-aligned-follow-up-packet-structure")))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-broad-recommended");
			}
			if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
				|| Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
				|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(
					TEXT("coach-memory-aligned-follow-up-packet-structure")))
			{
				Snapshot.PreferredCoachHandoffKind =
					EHyperTwistTrainingCoachHandoffKind::Recommended;
				Snapshot.PreferredCoachHandoffSourceLabel =
					TEXT("coach-memory-aligned-follow-up-packet-structure-broad-recommended");
			}
		}
	}

	const TArray<FHyperTwistTrainingCoachSessionQueueState> QueueStates =
		ListCoachSessionQueueStatesForUser(RepositoryState, UserId);
	if (QueueStates.Num() > 0)
	{
		const FHyperTwistTrainingCoachSessionQueueState& ActiveQueueState = QueueStates[0];
		const FHyperTwistTrainingCoachSessionQueueExecutionSummary QueueExecutionSummary =
			DeriveCoachSessionQueueExecutionSummary(
				RepositoryState,
				UserId,
				ActiveQueueState.QueueId,
				Snapshot.ReferenceUtc
			);
		if (QueueExecutionSummary.IsStructurallyValid())
		{
			Snapshot.ScheduleDeferredEventCount = QueueExecutionSummary.DeferredEventCount;
			Snapshot.ScheduleManualRescheduleEventCount =
				QueueExecutionSummary.ManualRescheduleEventCount;
			Snapshot.ScheduleArchiveAwareEventCount = QueueExecutionSummary.ArchiveAwareEventCount;
			Snapshot.ScheduleBlockedFollowUpEventCount =
				QueueExecutionSummary.BlockedFollowUpEventCount;
			Snapshot.ScheduleExecutionPressureScore =
				QueueExecutionSummary.ExecutionPressureScore;
			Snapshot.DominantScheduleDeferralReasonLabel =
				QueueExecutionSummary.DominantDeferralReasonLabel;
			Snapshot.bHasOutstandingDeferredScheduleWork =
				QueueExecutionSummary.bHasOutstandingDeferredWork;
			Snapshot.bHasQueueExecutionCompletionGap =
				QueueExecutionSummary.bHasCompletionGap;
			Snapshot.bHasArchiveAwareScheduleFriction =
				QueueExecutionSummary.bHasArchiveAwareFriction;
			Snapshot.bHasBlockedFollowUpScheduleFriction =
				QueueExecutionSummary.bHasBlockedFollowUpFriction;
			Snapshot.bHasRepeatManualScheduleFriction =
				QueueExecutionSummary.bHasRepeatManualRescheduleFriction;
			Snapshot.bNeedsScheduleFrictionRecovery =
				QueueExecutionSummary.ExecutionPressureScore >= 25.0f
				|| QueueExecutionSummary.bHasOutstandingDeferredWork
				|| QueueExecutionSummary.bHasCompletionGap
				|| QueueExecutionSummary.bHasArchiveAwareFriction
				|| QueueExecutionSummary.bHasBlockedFollowUpFriction
				|| QueueExecutionSummary.bHasRepeatManualRescheduleFriction;

			const FHyperTwistTrainingCoachSessionQueueStateEntry* MostDeferredQueueEntry =
				HyperTwistTrainingRepositoryLibraryInternal::FindQueueEntryById(
					ActiveQueueState,
					QueueExecutionSummary.MostDeferredEntryId
				);
			const FHyperTwistTrainingCoachSessionQueueStateEntry* MostCompletedQueueEntry =
				HyperTwistTrainingRepositoryLibraryInternal::FindQueueEntryById(
					ActiveQueueState,
					QueueExecutionSummary.MostCompletedEntryId
				);
			const EHyperTwistTrainingCoachGuidanceLane DominantDeferredLane =
				HyperTwistTrainingRepositoryLibraryInternal::GuidanceLaneFromQueueEntry(
					MostDeferredQueueEntry
				);
			const EHyperTwistTrainingCoachGuidanceLane DominantCompletedLane =
				HyperTwistTrainingRepositoryLibraryInternal::GuidanceLaneFromQueueEntry(
					MostCompletedQueueEntry
				);
			const int32 DeferredRecoverySignal = FMath::Clamp(
				(QueueExecutionSummary.DeferredEventCount / 2)
				+ (QueueExecutionSummary.ManualRescheduleEventCount > 0 ? 1 : 0),
				0,
				3
			);
			const int32 PromotionRecoverySignal = FMath::Clamp(
				QueueExecutionSummary.PromotedEventCount
				+ (QueueExecutionSummary.CompletedEventCount > 0 ? 1 : 0),
				0,
				3
			);
			const int32 ExplicitFollowUpRecoverySignal = FMath::Clamp(
				(QueueExecutionSummary.PromotedFollowUpEventCount * 2)
				+ QueueExecutionSummary.StartedFollowUpEventCount
				+ QueueExecutionSummary.CompletedFollowUpEventCount,
				0,
				5
			);
			const int32 ExplicitRecommendedRecoverySignal = FMath::Clamp(
				(QueueExecutionSummary.PromotedRecommendedEventCount * 2)
				+ QueueExecutionSummary.StartedRecommendedEventCount
				+ QueueExecutionSummary.CompletedRecommendedEventCount,
				0,
				5
			);
			int32 ExplicitQueuedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedQueuedHandoffEventCount,
				0,
				3
			);
			int32 ExplicitFollowUpHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedFollowUpHandoffEventCount * 2,
				0,
				4
			);
			int32 ExplicitRecommendedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedRecommendedHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitDeferredOverflowQueuedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedDeferredOverflowQueuedHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitDeferredOverflowFollowUpHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedDeferredOverflowFollowUpHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitDeferredOverflowRecommendedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedDeferredOverflowRecommendedHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitDeferredFirstQueuedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedDeferredFirstQueuedHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitDeferredFirstFollowUpHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedDeferredFirstFollowUpHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitDeferredFirstRecommendedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedDeferredFirstRecommendedHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitMethodDrillQueuedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedMethodDrillQueuedHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitMethodDrillFollowUpHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedMethodDrillFollowUpHandoffEventCount * 2,
				0,
				4
			);
			const int32 ExplicitMethodDrillRecommendedHandoffSignal = FMath::Clamp(
				QueueExecutionSummary.StartedMethodDrillRecommendedHandoffEventCount * 2,
				0,
				4
			);
			const int32 MethodDrillRecoveryStartedCount =
				QueueExecutionSummary.StartedMethodDrillQueuedHandoffEventCount
				+ QueueExecutionSummary.StartedMethodDrillFollowUpHandoffEventCount
				+ QueueExecutionSummary.StartedMethodDrillRecommendedHandoffEventCount;
			const int32 MethodDrillRecoveryCompletedCount =
				QueueExecutionSummary.CompletedMethodDrillQueuedHandoffEventCount
				+ QueueExecutionSummary.CompletedMethodDrillFollowUpHandoffEventCount
				+ QueueExecutionSummary.CompletedMethodDrillRecommendedHandoffEventCount;
			const int32 MethodDrillRecoveryOutstandingCount = FMath::Max(
				0,
				MethodDrillRecoveryStartedCount - MethodDrillRecoveryCompletedCount
			);
			const int32 StrongMethodDrillRecoveryMemoryStartedCount =
				QueueExecutionSummary.StartedStrongMethodDrillRecoveryMemoryHandoffEventCount;
			const int32 StrongMethodDrillRecoveryMemoryCompletedCount =
				QueueExecutionSummary.CompletedStrongMethodDrillRecoveryMemoryHandoffEventCount;
			const int32 StrongMethodDrillRecoveryMemoryOutstandingCount = FMath::Max(
				0,
				StrongMethodDrillRecoveryMemoryStartedCount
					- StrongMethodDrillRecoveryMemoryCompletedCount
			);
			const int32 WeakMethodDrillRecoveryMemoryStartedCount =
				QueueExecutionSummary.StartedWeakMethodDrillRecoveryMemoryHandoffEventCount;
			const int32 WeakMethodDrillRecoveryMemoryCompletedCount =
				QueueExecutionSummary.CompletedWeakMethodDrillRecoveryMemoryHandoffEventCount;
			const int32 WeakMethodDrillRecoveryMemoryOutstandingCount = FMath::Max(
				0,
				WeakMethodDrillRecoveryMemoryStartedCount
					- WeakMethodDrillRecoveryMemoryCompletedCount
			);
			const int32 StrongRetainedMethodDrillRecoveryPostureStartedCount =
				QueueExecutionSummary.StartedStrongRetainedMethodDrillRecoveryPostureHandoffEventCount;
			const int32 StrongRetainedMethodDrillRecoveryPostureCompletedCount =
				QueueExecutionSummary.CompletedStrongRetainedMethodDrillRecoveryPostureHandoffEventCount;
			const int32 StrongRetainedMethodDrillRecoveryPostureOutstandingCount = FMath::Max(
				0,
				StrongRetainedMethodDrillRecoveryPostureStartedCount
					- StrongRetainedMethodDrillRecoveryPostureCompletedCount
			);
			const int32 WeakRetainedMethodDrillRecoveryPostureStartedCount =
				QueueExecutionSummary.StartedWeakRetainedMethodDrillRecoveryPostureHandoffEventCount;
			const int32 WeakRetainedMethodDrillRecoveryPostureCompletedCount =
				QueueExecutionSummary.CompletedWeakRetainedMethodDrillRecoveryPostureHandoffEventCount;
			const int32 WeakRetainedMethodDrillRecoveryPostureOutstandingCount = FMath::Max(
				0,
				WeakRetainedMethodDrillRecoveryPostureStartedCount
					- WeakRetainedMethodDrillRecoveryPostureCompletedCount
			);
			const int32 NarrowMethodDrillRecoveryStructureStartedCount =
				QueueExecutionSummary.StartedNarrowMethodDrillRecoveryStructureHandoffEventCount;
			const int32 NarrowMethodDrillRecoveryStructureCompletedCount =
				QueueExecutionSummary.CompletedNarrowMethodDrillRecoveryStructureHandoffEventCount;
			const int32 NarrowMethodDrillRecoveryStructureOutstandingCount = FMath::Max(
				0,
				NarrowMethodDrillRecoveryStructureStartedCount
					- NarrowMethodDrillRecoveryStructureCompletedCount
			);
			const int32 BroadMethodDrillRecoveryStructureStartedCount =
				QueueExecutionSummary.StartedBroadMethodDrillRecoveryStructureHandoffEventCount;
			const int32 BroadMethodDrillRecoveryStructurePromotedCount =
				QueueExecutionSummary.PromotedBroadMethodDrillRecoveryStructureHandoffEventCount;
			const int32 BroadMethodDrillRecoveryStructureCompletedCount =
				QueueExecutionSummary.CompletedBroadMethodDrillRecoveryStructureHandoffEventCount;
			const int32 BroadMethodDrillRecoveryStructureOutstandingCount = FMath::Max(
				0,
				BroadMethodDrillRecoveryStructureStartedCount
					- BroadMethodDrillRecoveryStructureCompletedCount
			);
			const int32 TightMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TightMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TightMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TightMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
				0,
				TightMethodDrillRecoveryStructurePlanStartedCount
					- TightMethodDrillRecoveryStructurePlanCompletedCount
			);
			const int32 BroadMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 BroadMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 BroadMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 BroadMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
				0,
				BroadMethodDrillRecoveryStructurePlanStartedCount
					- BroadMethodDrillRecoveryStructurePlanCompletedCount
			);
			const int32 TrustedTightMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TrustedTightMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TrustedTightMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TrustedTightMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
				0,
				TrustedTightMethodDrillRecoveryStructurePlanStartedCount
					- TrustedTightMethodDrillRecoveryStructurePlanCompletedCount
			);
			const int32 TrustedBroadMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
				0,
				TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					- TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
			);
			const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
				0,
				ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					- ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
			);
			const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount = FMath::Max(
				0,
				ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					- ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
			);
			const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount =
				FMath::Max(
					0,
					ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
						- ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
				);
			const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount =
				QueueExecutionSummary.StartedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount =
				QueueExecutionSummary.PromotedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount =
				QueueExecutionSummary.CompletedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount;
			const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount =
				FMath::Max(
					0,
					ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
						- ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
				);
			if (MethodDrillRecoveryStartedCount > 0)
			{
				Snapshot.MethodDrillRecoveryHistoryCount += MethodDrillRecoveryStartedCount;
				Snapshot.StrongMethodDrillRecoveryHistoryCount += MethodDrillRecoveryCompletedCount;
				Snapshot.WeakMethodDrillRecoveryHistoryCount += MethodDrillRecoveryOutstandingCount;
				Snapshot.MethodDrillRecoveryAverageOutcomeScore =
					(static_cast<float>(MethodDrillRecoveryCompletedCount) * 100.0f)
					/ static_cast<float>(MethodDrillRecoveryStartedCount);
			}
			if ((TrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ TrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
				> 0)
			{
				const int32 TrustedTightMethodDrillRecoveryStructurePlanEventCount =
					TrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ TrustedTightMethodDrillRecoveryStructurePlanPromotedCount;
				Snapshot.TrustedTightMethodDrillRecoveryStructurePlanHistoryCount +=
					TrustedTightMethodDrillRecoveryStructurePlanEventCount;
				Snapshot.TrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore =
					(static_cast<float>(TrustedTightMethodDrillRecoveryStructurePlanCompletedCount)
						* 100.0f)
					/ static_cast<float>(TrustedTightMethodDrillRecoveryStructurePlanEventCount);
			}
			if ((TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
				> 0)
			{
				const int32 TrustedBroadMethodDrillRecoveryStructurePlanEventCount =
					TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount;
				const int32 TrustedBroadMethodDrillRecoveryStructurePlanRedirectCount = FMath::Max(
					0,
					TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
						- TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
				);
				Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanHistoryCount +=
					TrustedBroadMethodDrillRecoveryStructurePlanEventCount;
				Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore =
					(static_cast<float>(TrustedBroadMethodDrillRecoveryStructurePlanRedirectCount)
						* 100.0f)
					/ static_cast<float>(TrustedBroadMethodDrillRecoveryStructurePlanEventCount);
			}
			if ((ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
				> 0)
			{
				const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanEventCount =
					ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount;
				Snapshot.ReliableTrustedTightMethodDrillRecoveryStructurePlanHistoryCount +=
					ReliableTrustedTightMethodDrillRecoveryStructurePlanEventCount;
				Snapshot.ReliableTrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore =
					(static_cast<float>(ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount)
						* 100.0f)
					/ static_cast<float>(ReliableTrustedTightMethodDrillRecoveryStructurePlanEventCount);
			}
			if ((ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
				> 0)
			{
				const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanEventCount =
					ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount;
				const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount =
					FMath::Max(
						0,
						ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
							+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
							- ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
					);
				Snapshot.ReliableTrustedBroadMethodDrillRecoveryStructurePlanHistoryCount +=
					ReliableTrustedBroadMethodDrillRecoveryStructurePlanEventCount;
				Snapshot.ReliableTrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore =
					(static_cast<float>(ReliableTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount)
						* 100.0f)
					/ static_cast<float>(ReliableTrustedBroadMethodDrillRecoveryStructurePlanEventCount);
			}
			if ((ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
				> 0)
			{
				const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanEventCount =
					ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount;
				Snapshot.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHistoryCount +=
					ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanEventCount;
				Snapshot.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore =
					(static_cast<float>(
						 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount)
						* 100.0f)
					/ static_cast<float>(
						ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanEventCount);
			}
			if ((ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
				> 0)
			{
				const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanEventCount =
					ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
					+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount;
				const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount =
					FMath::Max(
						0,
						ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
							+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
							- ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
					);
				Snapshot.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHistoryCount +=
					ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanEventCount;
				Snapshot.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore =
					(static_cast<float>(
						 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanRedirectCount)
						* 100.0f)
					/ static_cast<float>(
						ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanEventCount);
			}
			const bool bStrongMethodDrillRecoveryHistory =
				MethodDrillRecoveryStartedCount >= 2
				&& MethodDrillRecoveryCompletedCount >= MethodDrillRecoveryOutstandingCount
				&& Snapshot.MethodDrillRecoveryAverageOutcomeScore >= 55.0f;
			const bool bWeakMethodDrillRecoveryHistory =
				MethodDrillRecoveryStartedCount >= 2
				&& MethodDrillRecoveryOutstandingCount > MethodDrillRecoveryCompletedCount
				&& Snapshot.MethodDrillRecoveryAverageOutcomeScore <= 45.0f;
			const int32 MethodDrillRecoveryLaunchBias = bStrongMethodDrillRecoveryHistory
				? FMath::Clamp(
					MethodDrillRecoveryCompletedCount
						- MethodDrillRecoveryOutstandingCount
						+ (Snapshot.MethodDrillRecoveryAverageOutcomeScore >= 75.0f ? 1 : 0),
					1,
					3)
				: 0;
			const int32 MethodDrillRecoveryPromoteBias = bWeakMethodDrillRecoveryHistory
				? FMath::Clamp(
					MethodDrillRecoveryOutstandingCount
						- MethodDrillRecoveryCompletedCount
						+ (QueueExecutionSummary.bHasCompletionGap ? 1 : 0),
					1,
					3)
				: 0;
			const int32 RetainedMethodDrillRecoveryLaunchBias =
				StrongMethodDrillRecoveryMemoryStartedCount > 0
					? FMath::Clamp(
						(StrongMethodDrillRecoveryMemoryCompletedCount * 2)
							- StrongMethodDrillRecoveryMemoryStartedCount
							+ 1,
						1,
						3)
					: 0;
			const int32 RetainedMethodDrillRecoveryPromoteBias =
				WeakMethodDrillRecoveryMemoryStartedCount > 0
					? FMath::Clamp(
						(WeakMethodDrillRecoveryMemoryOutstandingCount * 2)
							- WeakMethodDrillRecoveryMemoryCompletedCount
							+ 1,
						1,
						3)
					: 0;
			const int32 RetainedMethodDrillRecoveryPostureLaunchBias =
				StrongRetainedMethodDrillRecoveryPostureStartedCount > 0
					? FMath::Clamp(
						(StrongRetainedMethodDrillRecoveryPostureCompletedCount * 2)
							- StrongRetainedMethodDrillRecoveryPostureOutstandingCount
							+ 1,
						1,
						3)
					: 0;
			const int32 RetainedMethodDrillRecoveryPosturePromoteBias =
				WeakRetainedMethodDrillRecoveryPostureStartedCount > 0
					? FMath::Clamp(
						(WeakRetainedMethodDrillRecoveryPostureOutstandingCount * 2)
							- WeakRetainedMethodDrillRecoveryPostureCompletedCount
							+ 1,
						1,
						3)
					: 0;
			const int32 NarrowMethodDrillRecoveryStructureLaunchBias =
				NarrowMethodDrillRecoveryStructureStartedCount >= 2
					? FMath::Clamp(
						(NarrowMethodDrillRecoveryStructureCompletedCount * 2)
							- NarrowMethodDrillRecoveryStructureOutstandingCount
							+ 1,
						1,
						3)
					: 0;
			const int32 BroadMethodDrillRecoveryStructurePromoteBias =
				(BroadMethodDrillRecoveryStructurePromotedCount
						+ BroadMethodDrillRecoveryStructureStartedCount)
						>= 2
					? FMath::Clamp(
						BroadMethodDrillRecoveryStructurePromotedCount
							+ BroadMethodDrillRecoveryStructureOutstandingCount
							- BroadMethodDrillRecoveryStructureCompletedCount
							+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
						1,
						3)
					: 0;
			const int32 TightMethodDrillRecoveryStructurePlanLaunchBias =
				(TightMethodDrillRecoveryStructurePlanStartedCount
						+ TightMethodDrillRecoveryStructurePlanPromotedCount)
						>= 2
					? FMath::Clamp(
						(TightMethodDrillRecoveryStructurePlanCompletedCount * 2)
							- TightMethodDrillRecoveryStructurePlanOutstandingCount
							- TightMethodDrillRecoveryStructurePlanPromotedCount
							+ 1,
						1,
						3)
					: 0;
			const int32 BroadMethodDrillRecoveryStructurePlanPromoteBias =
				(BroadMethodDrillRecoveryStructurePlanPromotedCount
						+ BroadMethodDrillRecoveryStructurePlanStartedCount)
						>= 2
					? FMath::Clamp(
						BroadMethodDrillRecoveryStructurePlanPromotedCount
							+ BroadMethodDrillRecoveryStructurePlanOutstandingCount
							- BroadMethodDrillRecoveryStructurePlanCompletedCount
							+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
						1,
						3)
					: 0;
			const bool bTrustedTightMethodDrillRecoveryStructurePlanHistory =
				(TrustedTightMethodDrillRecoveryStructurePlanStartedCount
						+ TrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
					>= 2
				&& TrustedTightMethodDrillRecoveryStructurePlanCompletedCount
					>= TrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
				&& Snapshot.TrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore >= 60.0f;
			const bool bTrustedBroadMethodDrillRecoveryStructurePlanHistory =
				(TrustedBroadMethodDrillRecoveryStructurePlanStartedCount
						+ TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
					>= 2
				&& (TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount)
					>= TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
				&& Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore >= 60.0f;
			const int32 TrustedTightMethodDrillRecoveryStructurePlanLaunchBias =
				bTrustedTightMethodDrillRecoveryStructurePlanHistory
					? FMath::Clamp(
						(TrustedTightMethodDrillRecoveryStructurePlanCompletedCount * 2)
							- TrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
							- TrustedTightMethodDrillRecoveryStructurePlanPromotedCount
							+ (Snapshot.TrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore
									>= 80.0f
								? 1
								: 0),
						1,
						3)
					: 0;
			const int32 TrustedBroadMethodDrillRecoveryStructurePlanPromoteBias =
				bTrustedBroadMethodDrillRecoveryStructurePlanHistory
					? FMath::Clamp(
						TrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
							+ TrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
							- TrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
							+ (Snapshot.TrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore
									>= 80.0f
								? 1
								: 0)
							+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
						1,
						3)
					: 0;
			const bool bReliableTrustedTightMethodDrillRecoveryStructurePlanHistory =
				(ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount
						+ ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
					>= 2
				&& ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
					>= ReliableTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
				&& Snapshot.ReliableTrustedTightMethodDrillRecoveryStructurePlanAverageOutcomeScore
					>= 60.0f;
			const bool bReliableTrustedBroadMethodDrillRecoveryStructurePlanHistory =
				(ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
						+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
					>= 2
				&& (ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount)
					>= ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
				&& Snapshot.ReliableTrustedBroadMethodDrillRecoveryStructurePlanAverageOutcomeScore
					>= 60.0f;
			const int32 ReliableTrustedTightMethodDrillRecoveryStructurePlanLaunchBias =
				bReliableTrustedTightMethodDrillRecoveryStructurePlanHistory
					? FMath::Clamp(
						(ReliableTrustedTightMethodDrillRecoveryStructurePlanCompletedCount * 2)
							- ReliableTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
							- ReliableTrustedTightMethodDrillRecoveryStructurePlanPromotedCount
							+ 1,
						1,
						3)
					: 0;
			const int32 ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias =
				bReliableTrustedBroadMethodDrillRecoveryStructurePlanHistory
					? FMath::Clamp(
						ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
							+ ReliableTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
							- ReliableTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
							+ 1
							+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
						1,
						3)
					: 0;
			const bool bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHistory =
				(ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanStartedCount
						+ ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount)
					>= 2
				&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount
					>= ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount;
			const bool bReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHistory =
				(ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanStartedCount
						+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount)
					>= 2
				&& (ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
						+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount)
					>= ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount;
			const int32 ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias =
				bReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHistory
					? FMath::Clamp(
						(ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCompletedCount * 2)
							- ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutstandingCount
							- ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanPromotedCount
							+ 2,
						1,
						4)
					: 0;
			const int32 ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias =
				bReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHistory
					? FMath::Clamp(
						ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromotedCount
							+ ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutstandingCount
							- ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCompletedCount
							+ 2
							+ (QueueExecutionSummary.bHasOutstandingDeferredWork ? 1 : 0),
						1,
						4)
					: 0;
			const int32 StrongMethodDrillFollowUpPacketStartedCount =
				QueueExecutionSummary.StartedStrongMethodDrillFollowUpPacketQueuedHandoffEventCount
				+ QueueExecutionSummary.StartedStrongMethodDrillFollowUpPacketFollowUpHandoffEventCount
				+ QueueExecutionSummary.StartedStrongMethodDrillFollowUpPacketRecommendedHandoffEventCount;
			const int32 WeakMethodDrillFollowUpPacketStartedCount =
				QueueExecutionSummary.StartedWeakMethodDrillFollowUpPacketQueuedHandoffEventCount
				+ QueueExecutionSummary.StartedWeakMethodDrillFollowUpPacketFollowUpHandoffEventCount
				+ QueueExecutionSummary.StartedWeakMethodDrillFollowUpPacketRecommendedHandoffEventCount;
			const int32 AlignedTightFollowUpPacketAcceptedStartedCount =
				QueueExecutionSummary.StartedAlignedTightFollowUpPacketQueuedHandoffEventCount
				+ QueueExecutionSummary.StartedAlignedTightFollowUpPacketFollowUpHandoffEventCount
				+ QueueExecutionSummary.StartedAlignedTightFollowUpPacketRecommendedHandoffEventCount;
			const int32 AlignedBroadRecommendedPacketAcceptedStartedCount =
				QueueExecutionSummary.StartedAlignedBroadRecommendedPacketQueuedHandoffEventCount
				+ QueueExecutionSummary.StartedAlignedBroadRecommendedPacketFollowUpHandoffEventCount
				+ QueueExecutionSummary.StartedAlignedBroadRecommendedPacketRecommendedHandoffEventCount;
			const int32 AcceptedAlignedTightPacketOutcomeTrustSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore >= 60.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
							- Snapshot.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
							+ (Snapshot.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore
										>= 80.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 AcceptedAlignedBroadPacketOutcomeTrustSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore >= 58.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
							- Snapshot.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
							+ (Snapshot.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore
										>= 78.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 AcceptedAlignedTightPacketRetainedTrustSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore
						>= 65.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount
							- Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount
							+ (Snapshot.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore
										>= 82.0f
								? 1
								: 0),
						1,
						3)
					: 0;
			const int32 AcceptedAlignedBroadPacketRetainedTrustSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore
						>= 63.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount
							- Snapshot.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount
							+ (Snapshot.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore
										>= 80.0f
								? 1
								: 0),
						1,
						3)
					: 0;
			const int32 AcceptedAlignedTightPacketReliableTrustSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount >= 2
					&& Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableAverageOutcomeScore
						>= 62.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount
							- Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount
							+ (Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableAverageOutcomeScore
										>= 80.0f
								? 1
								: 0),
						1,
						3)
					: 0;
			const int32 AcceptedAlignedBroadPacketReliableTrustSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount >= 2
					&& Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore
						>= 60.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableHistoryCount
							- Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableHistoryCount
							+ (Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableAverageOutcomeScore
										>= 78.0f
								? 1
								: 0),
						1,
						3)
					: 0;
			const int32 AcceptedAlignedTightPacketReliableOutcomeSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
						>= 68.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
								   >= 84.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 AcceptedAlignedBroadPacketReliableOutcomeSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
						>= 66.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
							- Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
								   >= 82.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 AcceptedAlignedTightPacketReliableCompositeSignal =
				FMath::Max(
					AcceptedAlignedTightPacketReliableTrustSignal,
					AcceptedAlignedTightPacketReliableOutcomeSignal);
			const int32 AcceptedAlignedBroadPacketReliableCompositeSignal =
				FMath::Max(
					AcceptedAlignedBroadPacketReliableTrustSignal,
					AcceptedAlignedBroadPacketReliableOutcomeSignal);
			const int32 ReliableAcceptedAlignedTightPacketAcceptedSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAcceptedAverageScore
						>= 62.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAcceptedAverageScore
								   >= 80.0f
								? 1
								: 0),
						1,
						3)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketAcceptedSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAcceptedAverageScore
						>= 60.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAcceptedAverageScore
								   >= 78.0f
								? 1
								: 0),
						1,
						3)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAverageScore
						>= 70.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAverageScore
								   >= 86.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAverageScore
						>= 68.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAverageScore
								   >= 84.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactAcceptedSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactAcceptedHistoryCount >= 2
					&& Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactAcceptedAverageScore
						>= 64.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactAcceptedAverageScore
								   >= 82.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactAcceptedSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactAcceptedAverageScore
						>= 62.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactAcceptedAverageScore
								   >= 80.0f
								? 1
								: 0),
						1,
						4)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactCompositeSignal = FMath::Max(
				ReliableAcceptedAlignedTightPacketExactAcceptedSignal,
				(ReliableAcceptedAlignedTightPacketAcceptedSignal > 0
					&& ReliableAcceptedAlignedTightPacketExactOutcomeSignal > 0)
					? FMath::Clamp(
						FMath::Min(
							ReliableAcceptedAlignedTightPacketAcceptedSignal,
							ReliableAcceptedAlignedTightPacketExactOutcomeSignal) + 1,
						1,
						4)
					: 0);
			const int32 ReliableAcceptedAlignedBroadPacketExactCompositeSignal = FMath::Max(
				ReliableAcceptedAlignedBroadPacketExactAcceptedSignal,
				(ReliableAcceptedAlignedBroadPacketAcceptedSignal > 0
					&& ReliableAcceptedAlignedBroadPacketExactOutcomeSignal > 0)
					? FMath::Clamp(
						FMath::Min(
							ReliableAcceptedAlignedBroadPacketAcceptedSignal,
							ReliableAcceptedAlignedBroadPacketExactOutcomeSignal) + 1,
						1,
						4)
					: 0);
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeHistorySignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount >= 2
					&& Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAverageScore
						>= 74.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAverageScore
								   >= 88.0f
								? 1
								: 0),
						1,
						5)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeHistorySignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAverageScore
						>= 72.0f)
					? FMath::Clamp(
						Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAverageScore
								   >= 86.0f
								? 1
								: 0),
						1,
						5)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeAcceptedSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAcceptedAverageScore
						>= 66.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAcceptedAverageScore
								   >= 84.0f
								? 1
								: 0),
						1,
						5)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeAcceptedSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAcceptedAverageScore
						>= 64.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAcceptedAverageScore
								   >= 82.0f
								? 1
								: 0),
						1,
						5)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableSignal =
				(Snapshot.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore
						>= 70.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore
								   >= 86.0f
								? 1
								: 0),
						1,
						6)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableSignal =
				(Snapshot.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore
						>= 68.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore
								   >= 84.0f
								? 1
								: 0),
						1,
						6)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAcceptedAverageScore
						>= 72.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAcceptedAverageScore
								   >= 88.0f
								? 1
								: 0),
						1,
						7)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAcceptedAverageScore
						>= 70.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAcceptedAverageScore
								   >= 86.0f
								? 1
								: 0),
						1,
						7)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedAverageScore
						>= 74.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedAverageScore
								   >= 90.0f
								? 1
								: 0),
						1,
						8)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedAverageScore
						>= 72.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAcceptedAverageScore
								   >= 88.0f
								? 1
								: 0),
						1,
						8)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 76.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 92.0f
								? 1
								: 0),
						1,
						9)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 74.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 90.0f
								? 1
								: 0),
						1,
						9)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 78.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 94.0f
								? 1
								: 0),
						1,
						10)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 76.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 92.0f
								? 1
								: 0),
						1,
						10)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 80.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 96.0f
								? 1
								: 0),
						1,
						11)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 78.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 94.0f
								? 1
								: 0),
						1,
						11)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 82.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 98.0f
								? 1
								: 0),
						1,
						12)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 80.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 96.0f
								? 1
								: 0),
						1,
						12)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 84.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 100.0f
								? 1
								: 0),
						1,
						13)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 82.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 98.0f
								? 1
								: 0),
						1,
						13)
					: 0;
			const int32 ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 86.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 100.0f
								? 1
								: 0),
						1,
						14)
					: 0;
			const int32 ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 84.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 100.0f
								? 1
								: 0),
						1,
						14)
					: 0;
			const int32 HighestExactOutcomeTierAcceptedAlignedTightCompletionSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 88.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 100.0f
								? 1
								: 0),
						1,
						15)
					: 0;
			const int32 HighestExactOutcomeTierAcceptedAlignedBroadCompletionSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 86.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 100.0f
								? 1
								: 0),
						1,
						15)
					: 0;
			const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSignal =
				(Snapshot
						 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 90.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 100.0f
								? 1
								: 0),
						1,
						16)
					: 0;
			const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSignal =
				(Snapshot
						 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
						>= 2
					&& Snapshot
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						>= 88.0f)
					? FMath::Clamp(
						Snapshot
								.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							- Snapshot
									.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
							+ (Snapshot
									   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
								   >= 100.0f
								? 1
								: 0),
						1,
						16)
					: 0;
			if (AcceptedAlignedTightPacketOutcomeTrustSignal
				> AcceptedAlignedBroadPacketOutcomeTrustSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					AcceptedAlignedTightPacketOutcomeTrustSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount +=
					FMath::Max(1, AcceptedAlignedTightPacketOutcomeTrustSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (AcceptedAlignedTightPacketOutcomeTrustSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(2, AcceptedAlignedTightPacketOutcomeTrustSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-follow-up");
				}
			}
			else if (AcceptedAlignedBroadPacketOutcomeTrustSignal
				> AcceptedAlignedTightPacketOutcomeTrustSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					AcceptedAlignedBroadPacketOutcomeTrustSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					AcceptedAlignedBroadPacketOutcomeTrustSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (AcceptedAlignedBroadPacketOutcomeTrustSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-recommended");
				}
			}
			if (AcceptedAlignedTightPacketRetainedTrustSignal
				> AcceptedAlignedBroadPacketRetainedTrustSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					AcceptedAlignedTightPacketRetainedTrustSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					AcceptedAlignedTightPacketRetainedTrustSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal + AcceptedAlignedTightPacketRetainedTrustSignal,
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal + 1,
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-follow-up");
				}
			}
			else if (AcceptedAlignedBroadPacketRetainedTrustSignal
				> AcceptedAlignedTightPacketRetainedTrustSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					AcceptedAlignedBroadPacketRetainedTrustSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					AcceptedAlignedBroadPacketRetainedTrustSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal + AcceptedAlignedBroadPacketRetainedTrustSignal,
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-recommended");
				}
			}
			if (AcceptedAlignedTightPacketReliableCompositeSignal
				> AcceptedAlignedBroadPacketReliableCompositeSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					AcceptedAlignedTightPacketReliableCompositeSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					AcceptedAlignedTightPacketReliableCompositeSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (AcceptedAlignedTightPacketReliableCompositeSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal + 1,
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::FollowUp,
							true,
							true);
				}
			}
			else if (AcceptedAlignedBroadPacketReliableCompositeSignal
				> AcceptedAlignedTightPacketReliableCompositeSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					AcceptedAlignedBroadPacketReliableCompositeSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					AcceptedAlignedBroadPacketReliableCompositeSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (AcceptedAlignedBroadPacketReliableCompositeSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::Recommended,
							false,
							true);
				}
			}
			if (ReliableAcceptedAlignedTightPacketAcceptedSignal
				> ReliableAcceptedAlignedBroadPacketAcceptedSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketAcceptedSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketAcceptedSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal + ReliableAcceptedAlignedTightPacketAcceptedSignal,
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal + 1,
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-follow-up");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketAcceptedSignal
				> ReliableAcceptedAlignedTightPacketAcceptedSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketAcceptedSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketAcceptedSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal + ReliableAcceptedAlignedBroadPacketAcceptedSignal,
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-recommended");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(2, ReliableAcceptedAlignedTightPacketExactOutcomeSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-follow-up");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-recommended");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactCompositeSignal
				> ReliableAcceptedAlignedBroadPacketExactCompositeSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactCompositeSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactCompositeSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactCompositeSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(2, ReliableAcceptedAlignedTightPacketExactCompositeSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-follow-up");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactCompositeSignal
				> ReliableAcceptedAlignedTightPacketExactCompositeSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactCompositeSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactCompositeSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactCompositeSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-recommended");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeHistorySignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeHistorySignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeHistorySignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeHistorySignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeHistorySignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(2, ReliableAcceptedAlignedTightPacketExactOutcomeHistorySignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-follow-up");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeHistorySignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeHistorySignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeHistorySignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeHistorySignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeHistorySignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-recommended");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeAcceptedSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeAcceptedSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeAcceptedSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeAcceptedSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeAcceptedSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(2, ReliableAcceptedAlignedTightPacketExactOutcomeAcceptedSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-reliable-follow-up");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeAcceptedSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeAcceptedSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeAcceptedSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeAcceptedSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeAcceptedSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-reliable-recommended");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(2, ReliableAcceptedAlignedTightPacketExactOutcomeReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-tight-reliable-outcome-reliable-outcome-reliable-reliable-follow-up");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-accepted-aligned-follow-up-packet-broad-reliable-outcome-reliable-outcome-reliable-reliable-recommended");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal
						- 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
						- 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
						- 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
						- 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
						- 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
						- 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(
								2,
								ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
				> ReliableAcceptedAlignedTightPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (ReliableAcceptedAlignedBroadPacketExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
							* 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (HighestExactOutcomeTierAcceptedAlignedTightCompletionSignal
				> HighestExactOutcomeTierAcceptedAlignedBroadCompletionSignal)
			{
				Snapshot.FollowUpGuidanceContinueBias +=
					HighestExactOutcomeTierAcceptedAlignedTightCompletionSignal;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					HighestExactOutcomeTierAcceptedAlignedTightCompletionSignal - 1);
				ExplicitFollowUpHandoffSignal = FMath::Clamp(
					ExplicitFollowUpHandoffSignal
						+ (HighestExactOutcomeTierAcceptedAlignedTightCompletionSignal * 2),
					0,
					6);
				if (QueueExecutionSummary.bHasOutstandingDeferredWork
					|| QueueExecutionSummary.StartedQueuedHandoffEventCount > 0)
				{
					ExplicitQueuedHandoffSignal = FMath::Clamp(
						ExplicitQueuedHandoffSignal
							+ FMath::Min(2, HighestExactOutcomeTierAcceptedAlignedTightCompletionSignal),
						0,
						5);
				}
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::Recommended
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::FollowUp;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			else if (HighestExactOutcomeTierAcceptedAlignedBroadCompletionSignal
				> HighestExactOutcomeTierAcceptedAlignedTightCompletionSignal)
			{
				Snapshot.RecommendedGuidanceContinueBias +=
					HighestExactOutcomeTierAcceptedAlignedBroadCompletionSignal;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					HighestExactOutcomeTierAcceptedAlignedBroadCompletionSignal;
				ExplicitRecommendedHandoffSignal = FMath::Clamp(
					ExplicitRecommendedHandoffSignal
						+ (HighestExactOutcomeTierAcceptedAlignedBroadCompletionSignal * 2),
					0,
					6);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeAcceptedHistorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
				if (Snapshot.PreferredCoachHandoffKind == EHyperTwistTrainingCoachHandoffKind::None
					|| Snapshot.PreferredCoachHandoffKind
						== EHyperTwistTrainingCoachHandoffKind::FollowUp
					|| Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
					|| Snapshot.PreferredCoachHandoffSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
				{
					Snapshot.PreferredCoachHandoffKind =
						EHyperTwistTrainingCoachHandoffKind::Recommended;
					Snapshot.PreferredCoachHandoffSourceLabel =
						TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable");
				}
			}
			if (StrongMethodDrillFollowUpPacketStartedCount > 0
				&& StrongMethodDrillFollowUpPacketStartedCount
					>= WeakMethodDrillFollowUpPacketStartedCount)
			{
				const int32 MethodDrillFollowUpPacketBias = FMath::Clamp(
					StrongMethodDrillFollowUpPacketStartedCount
						- WeakMethodDrillFollowUpPacketStartedCount
						+ 1,
					1,
					3
				);
				Snapshot.FollowUpGuidanceContinueBias += MethodDrillFollowUpPacketBias;
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					MethodDrillFollowUpPacketBias - 1
				);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-method-drill-follow-up-packet-strong");
				}
			}
			else if (WeakMethodDrillFollowUpPacketStartedCount > 0)
			{
				const int32 MethodDrillFollowUpPacketRedirectBias = FMath::Clamp(
					WeakMethodDrillFollowUpPacketStartedCount
						- StrongMethodDrillFollowUpPacketStartedCount
						+ 1,
					1,
					2
				);
				Snapshot.RecommendedGuidanceContinueBias += MethodDrillFollowUpPacketRedirectBias;
				Snapshot.SuppressedFollowUpQueuePressureCount += MethodDrillFollowUpPacketRedirectBias;
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("coach-memory-method-drill")))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-method-drill-follow-up-packet-weak");
				}
			}
			if (AlignedTightFollowUpPacketAcceptedStartedCount > 0
				&& AlignedTightFollowUpPacketAcceptedStartedCount
					>= AlignedBroadRecommendedPacketAcceptedStartedCount)
			{
				const int32 AlignedPacketAcceptedBias = FMath::Clamp(
					AlignedTightFollowUpPacketAcceptedStartedCount
						- AlignedBroadRecommendedPacketAcceptedStartedCount
						+ 1,
					1,
					3);
				Snapshot.FollowUpGuidanceContinueBias += AlignedPacketAcceptedBias;
				Snapshot.SuppressedPrimaryQueuePressureCount +=
					FMath::Max(1, AlignedPacketAcceptedBias - 1);
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::Recommended
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::FollowUp;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-aligned-follow-up-packet-tight-follow-up");
				}
			}
			else if (AlignedBroadRecommendedPacketAcceptedStartedCount > 0)
			{
				const int32 AlignedPacketAcceptedRedirectBias = FMath::Clamp(
					AlignedBroadRecommendedPacketAcceptedStartedCount
						- AlignedTightFollowUpPacketAcceptedStartedCount
						+ 1,
					1,
					3);
				Snapshot.RecommendedGuidanceContinueBias +=
					AlignedPacketAcceptedRedirectBias;
				Snapshot.SuppressedFollowUpQueuePressureCount +=
					AlignedPacketAcceptedRedirectBias;
				if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
					|| Snapshot.PreferredGuidanceLane
						== EHyperTwistTrainingCoachGuidanceLane::FollowUp
					|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("recommendation-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
						Snapshot.PreferredGuidanceSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
						Snapshot.PreferredGuidanceSourceLabel))
				{
					Snapshot.PreferredGuidanceLane =
						EHyperTwistTrainingCoachGuidanceLane::Recommended;
					Snapshot.PreferredGuidanceSourceLabel =
						TEXT("coach-memory-dashboard-aligned-follow-up-packet-broad-recommended");
				}
			}
			const bool bStrongMethodDrillRecoveryPacketQueuedHandoff =
				QueueExecutionSummary.StartedStrongMethodDrillRecoveryPacketQueuedHandoffEventCount > 0;
			const bool bStrongMethodDrillRecoveryPacketFollowUpHandoff =
				QueueExecutionSummary.StartedStrongMethodDrillRecoveryPacketFollowUpHandoffEventCount > 0;
			const bool bStrongMethodDrillRecoveryPacketRecommendedHandoff =
				QueueExecutionSummary.StartedStrongMethodDrillRecoveryPacketRecommendedHandoffEventCount > 0;
			const bool bStrongMethodDrillFollowUpPacketQueuedHandoff =
				QueueExecutionSummary.StartedStrongMethodDrillFollowUpPacketQueuedHandoffEventCount > 0;
			const bool bStrongMethodDrillFollowUpPacketFollowUpHandoff =
				QueueExecutionSummary.StartedStrongMethodDrillFollowUpPacketFollowUpHandoffEventCount > 0;
			const bool bStrongMethodDrillFollowUpPacketRecommendedHandoff =
				QueueExecutionSummary.StartedStrongMethodDrillFollowUpPacketRecommendedHandoffEventCount > 0;
			const bool bWeakMethodDrillRecoveryPacketQueuedHandoff =
				QueueExecutionSummary.StartedWeakMethodDrillRecoveryPacketQueuedHandoffEventCount > 0;
			const bool bWeakMethodDrillRecoveryPacketFollowUpHandoff =
				QueueExecutionSummary.StartedWeakMethodDrillRecoveryPacketFollowUpHandoffEventCount > 0;
			const bool bWeakMethodDrillRecoveryPacketRecommendedHandoff =
				QueueExecutionSummary.StartedWeakMethodDrillRecoveryPacketRecommendedHandoffEventCount > 0;
			const bool bWeakMethodDrillFollowUpPacketQueuedHandoff =
				QueueExecutionSummary.StartedWeakMethodDrillFollowUpPacketQueuedHandoffEventCount > 0;
			const bool bWeakMethodDrillFollowUpPacketFollowUpHandoff =
				QueueExecutionSummary.StartedWeakMethodDrillFollowUpPacketFollowUpHandoffEventCount > 0;
			const bool bWeakMethodDrillFollowUpPacketRecommendedHandoff =
				QueueExecutionSummary.StartedWeakMethodDrillFollowUpPacketRecommendedHandoffEventCount > 0;
			const bool bAlignedTightFollowUpPacketQueuedHandoff =
				QueueExecutionSummary.StartedAlignedTightFollowUpPacketQueuedHandoffEventCount > 0;
			const bool bAlignedTightFollowUpPacketFollowUpHandoff =
				QueueExecutionSummary.StartedAlignedTightFollowUpPacketFollowUpHandoffEventCount > 0;
			const bool bAlignedTightFollowUpPacketRecommendedHandoff =
				QueueExecutionSummary.StartedAlignedTightFollowUpPacketRecommendedHandoffEventCount > 0;
			const bool bAlignedBroadRecommendedPacketQueuedHandoff =
				QueueExecutionSummary.StartedAlignedBroadRecommendedPacketQueuedHandoffEventCount > 0;
			const bool bAlignedBroadRecommendedPacketFollowUpHandoff =
				QueueExecutionSummary.StartedAlignedBroadRecommendedPacketFollowUpHandoffEventCount > 0;
			const bool bAlignedBroadRecommendedPacketRecommendedHandoff =
				QueueExecutionSummary.StartedAlignedBroadRecommendedPacketRecommendedHandoffEventCount > 0;
			if (ExplicitQueuedHandoffSignal > 0
				|| ExplicitFollowUpHandoffSignal > 0
				|| ExplicitRecommendedHandoffSignal > 0)
			{
				if (ExplicitQueuedHandoffSignal >= ExplicitFollowUpHandoffSignal
					&& ExplicitQueuedHandoffSignal >= ExplicitRecommendedHandoffSignal)
				{
					const bool bRetainedMethodDrillRecoveryPostureDriven =
						ExplicitMethodDrillQueuedHandoffSignal > 0
						&& RetainedMethodDrillRecoveryPostureLaunchBias > 0;
					const HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias
						MethodDrillRecoveryMemoryBias =
						bRetainedMethodDrillRecoveryPostureDriven
							? HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
							: (ExplicitMethodDrillQueuedHandoffSignal > 0
							&& RetainedMethodDrillRecoveryLaunchBias > 0
							? HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
							: HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::None);
					Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Queue;
					if (bStrongMethodDrillFollowUpPacketQueuedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-follow-up-packet-strong-queued");
					}
					else if (AcceptedAlignedTightPacketOutcomeTrustSignal
							> AcceptedAlignedBroadPacketOutcomeTrustSignal)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::Queue,
								true,
								AcceptedAlignedTightPacketReliableCompositeSignal
									> AcceptedAlignedBroadPacketReliableCompositeSignal);
					}
					else if (AcceptedAlignedBroadPacketOutcomeTrustSignal
							> AcceptedAlignedTightPacketOutcomeTrustSignal)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::Queue,
								false,
								AcceptedAlignedBroadPacketReliableCompositeSignal
									> AcceptedAlignedTightPacketReliableCompositeSignal);
					}
					else if (bAlignedTightFollowUpPacketQueuedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-aligned-follow-up-packet-tight-queued");
					}
					else if (bAlignedBroadRecommendedPacketQueuedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-aligned-follow-up-packet-broad-queued");
					}
					else if (bWeakMethodDrillFollowUpPacketQueuedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-follow-up-packet-weak-queued");
					}
					else if (bStrongMethodDrillRecoveryPacketQueuedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-queued");
					}
					else if (bWeakMethodDrillRecoveryPacketQueuedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-queued");
					}
					else if (MethodDrillRecoveryMemoryBias
							== HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
						&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-queued");
					}
					else if (MethodDrillRecoveryMemoryBias
							== HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
						&& ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount > 0)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-queued");
					}
					else
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::Queue,
								ExplicitDeferredOverflowQueuedHandoffSignal > 0,
								ExplicitDeferredFirstQueuedHandoffSignal > 0,
								ExplicitMethodDrillQueuedHandoffSignal > 0,
								MethodDrillRecoveryMemoryBias,
								bRetainedMethodDrillRecoveryPostureDriven
							);
					}
				}
				else if (ExplicitFollowUpHandoffSignal >= ExplicitRecommendedHandoffSignal)
				{
					const bool bRetainedMethodDrillRecoveryPostureDriven =
						ExplicitMethodDrillFollowUpHandoffSignal > 0
						&& RetainedMethodDrillRecoveryPostureLaunchBias > 0;
					const HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias
						MethodDrillRecoveryMemoryBias =
						bRetainedMethodDrillRecoveryPostureDriven
							? HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
							: (ExplicitMethodDrillFollowUpHandoffSignal > 0
							&& RetainedMethodDrillRecoveryLaunchBias > 0
							? HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
							: HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::None);
					Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::FollowUp;
					if (bStrongMethodDrillFollowUpPacketFollowUpHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-follow-up-packet-strong-follow-up");
					}
					else if (AcceptedAlignedTightPacketOutcomeTrustSignal
							> AcceptedAlignedBroadPacketOutcomeTrustSignal)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::FollowUp,
								true,
								AcceptedAlignedTightPacketReliableCompositeSignal
									> AcceptedAlignedBroadPacketReliableCompositeSignal);
					}
					else if (AcceptedAlignedBroadPacketOutcomeTrustSignal
							> AcceptedAlignedTightPacketOutcomeTrustSignal)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::FollowUp,
								false,
								AcceptedAlignedBroadPacketReliableCompositeSignal
									> AcceptedAlignedTightPacketReliableCompositeSignal);
					}
					else if (bAlignedTightFollowUpPacketFollowUpHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-aligned-follow-up-packet-tight-follow-up");
					}
					else if (bAlignedBroadRecommendedPacketFollowUpHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-aligned-follow-up-packet-broad-follow-up");
					}
					else if (bWeakMethodDrillFollowUpPacketFollowUpHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-follow-up-packet-weak-follow-up");
					}
					else if (bStrongMethodDrillRecoveryPacketFollowUpHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-follow-up");
					}
					else if (bWeakMethodDrillRecoveryPacketFollowUpHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-follow-up");
					}
					else if (MethodDrillRecoveryMemoryBias
							== HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
						&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned-follow-up");
					}
					else if (MethodDrillRecoveryMemoryBias
							== HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Strong
						&& ReliableTrustedTightMethodDrillRecoveryStructurePlanStartedCount > 0)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-tight-trusted-reliable-follow-up");
					}
					else
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::FollowUp,
								ExplicitDeferredOverflowFollowUpHandoffSignal > 0,
								ExplicitDeferredFirstFollowUpHandoffSignal > 0,
								ExplicitMethodDrillFollowUpHandoffSignal > 0,
								MethodDrillRecoveryMemoryBias,
								bRetainedMethodDrillRecoveryPostureDriven
							);
					}
				}
				else
				{
					const bool bRetainedMethodDrillRecoveryPostureDriven =
						ExplicitMethodDrillRecommendedHandoffSignal > 0
						&& RetainedMethodDrillRecoveryPosturePromoteBias > 0;
					const HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias
						MethodDrillRecoveryMemoryBias =
						bRetainedMethodDrillRecoveryPostureDriven
							? HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Weak
							: (ExplicitMethodDrillRecommendedHandoffSignal > 0
							&& RetainedMethodDrillRecoveryPromoteBias > 0
							? HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Weak
							: HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::None);
					Snapshot.PreferredCoachHandoffKind = EHyperTwistTrainingCoachHandoffKind::Recommended;
					if (bStrongMethodDrillFollowUpPacketRecommendedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-follow-up-packet-strong-recommended");
					}
					else if (AcceptedAlignedTightPacketOutcomeTrustSignal
							> AcceptedAlignedBroadPacketOutcomeTrustSignal)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::Recommended,
								true,
								AcceptedAlignedTightPacketReliableCompositeSignal
									> AcceptedAlignedBroadPacketReliableCompositeSignal);
					}
					else if (AcceptedAlignedBroadPacketOutcomeTrustSignal
							> AcceptedAlignedTightPacketOutcomeTrustSignal)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::Recommended,
								false,
								AcceptedAlignedBroadPacketReliableCompositeSignal
									> AcceptedAlignedTightPacketReliableCompositeSignal);
					}
					else if (bAlignedTightFollowUpPacketRecommendedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-aligned-follow-up-packet-tight-recommended");
					}
					else if (bAlignedBroadRecommendedPacketRecommendedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-aligned-follow-up-packet-broad-recommended");
					}
					else if (bWeakMethodDrillFollowUpPacketRecommendedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-follow-up-packet-weak-recommended");
					}
					else if (bStrongMethodDrillRecoveryPacketRecommendedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-packet-strong-recommended");
					}
					else if (bWeakMethodDrillRecoveryPacketRecommendedHandoff)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-packet-weak-recommended");
					}
					else if (MethodDrillRecoveryMemoryBias
							== HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Weak
						&& ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias > 0)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned-recommended");
					}
					else if (MethodDrillRecoveryMemoryBias
							== HyperTwistTrainingRepositoryLibraryInternal::EMethodDrillRecoveryMemoryBias::Weak
						&& ReliableTrustedBroadMethodDrillRecoveryStructurePlanStartedCount > 0)
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							TEXT("coach-memory-dashboard-method-drill-recovery-structure-plan-broad-trusted-reliable-recommended");
					}
					else
					{
						Snapshot.PreferredCoachHandoffSourceLabel =
							HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
								EHyperTwistTrainingCoachHandoffKind::Recommended,
								ExplicitDeferredOverflowRecommendedHandoffSignal > 0,
								ExplicitDeferredFirstRecommendedHandoffSignal > 0,
								ExplicitMethodDrillRecommendedHandoffSignal > 0,
								MethodDrillRecoveryMemoryBias,
								bRetainedMethodDrillRecoveryPostureDriven
							);
					}
				}
			}
			const int32 WeightedFollowUpRecoverySignal =
				ExplicitFollowUpRecoverySignal
				+ ExplicitFollowUpHandoffSignal
				+ ExplicitDeferredOverflowFollowUpHandoffSignal
				+ ExplicitDeferredFirstQueuedHandoffSignal
				+ ExplicitDeferredFirstFollowUpHandoffSignal
				+ ExplicitMethodDrillQueuedHandoffSignal
				+ ExplicitMethodDrillFollowUpHandoffSignal
				+ MethodDrillRecoveryLaunchBias
				+ RetainedMethodDrillRecoveryLaunchBias
				+ RetainedMethodDrillRecoveryPostureLaunchBias
				+ TightMethodDrillRecoveryStructurePlanLaunchBias
				+ NarrowMethodDrillRecoveryStructureLaunchBias;
			const int32 WeightedRecommendedRecoverySignal =
				ExplicitRecommendedRecoverySignal
				+ ExplicitRecommendedHandoffSignal
				+ ExplicitDeferredOverflowRecommendedHandoffSignal
				+ ExplicitDeferredFirstRecommendedHandoffSignal
				+ ExplicitMethodDrillRecommendedHandoffSignal
				+ MethodDrillRecoveryPromoteBias
				+ RetainedMethodDrillRecoveryPromoteBias
				+ RetainedMethodDrillRecoveryPosturePromoteBias
				+ BroadMethodDrillRecoveryStructurePlanPromoteBias
				+ BroadMethodDrillRecoveryStructurePromoteBias;
			const bool bQueueHistoryPrefersFollowUp =
				DominantDeferredLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
				|| (DominantCompletedLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
					&& QueueExecutionSummary.PromotedEventCount > 0)
				|| WeightedFollowUpRecoverySignal > WeightedRecommendedRecoverySignal;
			const bool bQueueHistoryPrefersRecommended =
				DominantDeferredLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| (DominantCompletedLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
					&& QueueExecutionSummary.PromotedEventCount > 0)
				|| WeightedRecommendedRecoverySignal > WeightedFollowUpRecoverySignal;
			const float PromoteRecoveryActionPressure =
				(QueueExecutionSummary.bHasOutstandingDeferredWork ? 4.0f : 0.0f)
				+ FMath::Min(static_cast<float>(QueueExecutionSummary.DeferredEventCount) * 0.75f, 3.0f)
				+ FMath::Min(static_cast<float>(QueueExecutionSummary.PromotedEventCount), 3.0f)
			+ (DominantDeferredLane != EHyperTwistTrainingCoachGuidanceLane::None ? 1.5f : 0.0f)
			- (QueueExecutionSummary.bHasCompletionGap ? 1.0f : 0.0f)
			+ (static_cast<float>(MethodDrillRecoveryPromoteBias) * 1.5f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryPromoteBias) * 1.75f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryPosturePromoteBias) * 2.0f)
			+ (static_cast<float>(BroadMethodDrillRecoveryStructurePlanPromoteBias) * 2.75f)
			+ (static_cast<float>(BroadMethodDrillRecoveryStructurePromoteBias) * 2.5f);
			const float LaunchRecoveryActionPressure =
				(QueueExecutionSummary.bHasCompletionGap ? 4.0f : 0.0f)
				+ (QueueExecutionSummary.bHasBlockedFollowUpFriction ? 2.5f : 0.0f)
				+ (QueueExecutionSummary.bHasRepeatManualRescheduleFriction ? 2.0f : 0.0f)
				+ (QueueExecutionSummary.bHasArchiveAwareFriction ? 1.0f : 0.0f)
				+ FMath::Min(static_cast<float>(QueueExecutionSummary.CompletedEventCount), 3.0f)
				+ FMath::Min(static_cast<float>(QueueExecutionSummary.ManualRescheduleEventCount) * 0.5f, 2.0f)
				+ static_cast<float>(ExplicitQueuedHandoffSignal)
				+ static_cast<float>(ExplicitDeferredOverflowQueuedHandoffSignal)
				+ static_cast<float>(ExplicitDeferredFirstQueuedHandoffSignal)
				+ static_cast<float>(ExplicitDeferredFirstFollowUpHandoffSignal) * 0.5f
				+ static_cast<float>(ExplicitMethodDrillQueuedHandoffSignal)
			+ static_cast<float>(ExplicitMethodDrillFollowUpHandoffSignal)
			+ static_cast<float>(ExplicitMethodDrillRecommendedHandoffSignal) * 0.5f
			+ (static_cast<float>(MethodDrillRecoveryLaunchBias) * 1.75f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryLaunchBias) * 2.0f)
			+ (static_cast<float>(RetainedMethodDrillRecoveryPostureLaunchBias) * 2.25f)
			+ (static_cast<float>(TightMethodDrillRecoveryStructurePlanLaunchBias) * 2.75f)
			+ (static_cast<float>(NarrowMethodDrillRecoveryStructureLaunchBias) * 2.5f);
		if (PromoteRecoveryActionPressure > 0.0f || LaunchRecoveryActionPressure > 0.0f)
		{
			const FString PacketStructureRecoverySourceLabel =
				HyperTwistTrainingRepositoryLibraryInternal::
					ResolveMethodDrillFollowUpPacketStructureRecoverySourceLabel(
						Snapshot.PreferredCoachHandoffSourceLabel,
						Snapshot.PreferredGuidanceSourceLabel
					);
			if (PromoteRecoveryActionPressure > LaunchRecoveryActionPressure)
			{
				Snapshot.PreferredQueueRecoveryAction =
					EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred;
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					!PacketStructureRecoverySourceLabel.IsEmpty()
						? PacketStructureRecoverySourceLabel
						: TEXT("queue-history-promote-pressure");
			}
			else if (LaunchRecoveryActionPressure > PromoteRecoveryActionPressure)
			{
				Snapshot.PreferredQueueRecoveryAction =
					EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery;
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					!PacketStructureRecoverySourceLabel.IsEmpty()
						? PacketStructureRecoverySourceLabel
						: (!Snapshot.PreferredCoachHandoffSourceLabel.IsEmpty()
						? Snapshot.PreferredCoachHandoffSourceLabel
						: TEXT("queue-history-launch-pressure"));
			}
			else
			{
				Snapshot.PreferredQueueRecoveryAction =
					QueueExecutionSummary.bHasOutstandingDeferredWork
						&& !QueueExecutionSummary.bHasCompletionGap
						? EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
						: EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery;
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					!PacketStructureRecoverySourceLabel.IsEmpty()
						? PacketStructureRecoverySourceLabel
						: TEXT("queue-history-balanced-pressure");
			}
		}
			if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& HyperTwistTrainingRepositoryLibraryInternal::IsStrongMethodDrillRecoveryPacketCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-packet-strong");
			}
			else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& HyperTwistTrainingRepositoryLibraryInternal::IsWeakMethodDrillRecoveryPacketCoachMemorySource(
					Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-packet-weak");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable-aligned");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable-aligned");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& ReliableTrustedTightMethodDrillRecoveryStructurePlanLaunchBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted-reliable");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& ReliableTrustedBroadMethodDrillRecoveryStructurePlanPromoteBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted-reliable");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& HyperTwistTrainingRepositoryLibraryInternal::
					IsTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-tight-trusted");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& HyperTwistTrainingRepositoryLibraryInternal::
					IsTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						Snapshot.PreferredCoachHandoffSourceLabel))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-broad-trusted");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& TightMethodDrillRecoveryStructurePlanLaunchBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-tight");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& BroadMethodDrillRecoveryStructurePlanPromoteBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-plan-broad");
			}
			else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& NarrowMethodDrillRecoveryStructureLaunchBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-narrow");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& BroadMethodDrillRecoveryStructurePromoteBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-structure-broad");
			}
			else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& RetainedMethodDrillRecoveryPostureLaunchBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-posture-strong");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& RetainedMethodDrillRecoveryPosturePromoteBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-posture-weak");
			}
			else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& RetainedMethodDrillRecoveryLaunchBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-memory-strong");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& RetainedMethodDrillRecoveryPromoteBias > 0
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-memory-weak");
			}
			else if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery
				&& bStrongMethodDrillRecoveryHistory
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-strong");
			}
			else if (Snapshot.PreferredQueueRecoveryAction
					== EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
				&& bWeakMethodDrillRecoveryHistory
				&& (Snapshot.PreferredQueueRecoveryActionSourceLabel.IsEmpty()
					|| Snapshot.PreferredQueueRecoveryActionSourceLabel.StartsWith(TEXT("queue-history"))
					|| HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillRecoveryCoachMemorySource(
						Snapshot.PreferredQueueRecoveryActionSourceLabel)))
			{
				Snapshot.PreferredQueueRecoveryActionSourceLabel =
					TEXT("coach-memory-method-drill-recovery-weak");
			}

			if (bQueueHistoryPrefersFollowUp)
			{
				Snapshot.FollowUpGuidanceContinueBias += FMath::Max(
					1,
					DeferredRecoverySignal + PromotionRecoverySignal + WeightedFollowUpRecoverySignal
				);
			}
			if (bQueueHistoryPrefersRecommended)
			{
				Snapshot.RecommendedGuidanceContinueBias += FMath::Max(
					1,
					DeferredRecoverySignal + PromotionRecoverySignal + WeightedRecommendedRecoverySignal
						- (QueueExecutionSummary.bHasBlockedFollowUpFriction ? 1 : 0)
				);
			}
			if (MethodDrillRecoveryLaunchBias > 0)
			{
				Snapshot.FollowUpGuidanceContinueBias += MethodDrillRecoveryLaunchBias;
			}
			if (RetainedMethodDrillRecoveryLaunchBias > 0)
			{
				Snapshot.FollowUpGuidanceContinueBias += RetainedMethodDrillRecoveryLaunchBias;
			}
			if (NarrowMethodDrillRecoveryStructureLaunchBias > 0)
			{
				Snapshot.FollowUpGuidanceContinueBias += NarrowMethodDrillRecoveryStructureLaunchBias;
			}
			if (MethodDrillRecoveryPromoteBias > 0)
			{
				Snapshot.RecommendedGuidanceContinueBias += MethodDrillRecoveryPromoteBias;
			}
			if (RetainedMethodDrillRecoveryPromoteBias > 0)
			{
				Snapshot.RecommendedGuidanceContinueBias += RetainedMethodDrillRecoveryPromoteBias;
			}
			if (BroadMethodDrillRecoveryStructurePromoteBias > 0)
			{
				Snapshot.RecommendedGuidanceContinueBias += BroadMethodDrillRecoveryStructurePromoteBias;
			}
			if (bQueueHistoryPrefersFollowUp
				&& Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred)
			{
				Snapshot.SuppressedPrimaryQueuePressureCount += FMath::Max(
					1,
					DeferredRecoverySignal
						+ WeightedFollowUpRecoverySignal
						+ (QueueExecutionSummary.bHasBlockedFollowUpFriction ? 1 : 0)
				);
			}
			if (bQueueHistoryPrefersRecommended
				&& Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery)
			{
				Snapshot.SuppressedFollowUpQueuePressureCount += FMath::Max(
					1,
					PromotionRecoverySignal
						+ WeightedRecommendedRecoverySignal
						+ (QueueExecutionSummary.bHasCompletionGap ? 1 : 0)
				);
			}

			if (!QueueExecutionSummary.FocusDeckId.IsEmpty()
				&& (Snapshot.FocusDeckId.IsEmpty() || Snapshot.bNeedsScheduleFrictionRecovery))
			{
				Snapshot.FocusDeckId = QueueExecutionSummary.FocusDeckId;
			}
			if (!QueueExecutionSummary.FocusMethodSegmentId.IsEmpty()
				&& (Snapshot.FocusMethodSegmentId.IsEmpty() || Snapshot.bNeedsScheduleFrictionRecovery))
			{
				Snapshot.FocusMethodSegmentId = QueueExecutionSummary.FocusMethodSegmentId;
			}

			TArray<FString> PrioritizedSchedulePressureCaseIds;
			const auto AppendSchedulePressureCaseIds = [&PrioritizedSchedulePressureCaseIds](
				const TArray<FString>& SourceCaseIds)
			{
				for (const FString& CaseId : SourceCaseIds)
				{
					if (!CaseId.IsEmpty() && !PrioritizedSchedulePressureCaseIds.Contains(CaseId))
					{
						PrioritizedSchedulePressureCaseIds.Add(CaseId);
					}
				}
			};

			if (QueueExecutionSummary.bHasBlockedFollowUpFriction)
			{
				AppendSchedulePressureCaseIds(Snapshot.PinnedCarryForwardCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.EscalationCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.PersistentCoachWeakCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.RecurringCoachCaseIds);
			}
			if (QueueExecutionSummary.bHasArchiveAwareFriction)
			{
				AppendSchedulePressureCaseIds(Snapshot.ArchiveReopenRiskCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.ProvisionalArchivedCoachCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.PinnedCarryForwardCaseIds);
			}
			if (QueueExecutionSummary.bHasRepeatManualRescheduleFriction)
			{
				AppendSchedulePressureCaseIds(Snapshot.OverdueCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.DueCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.WeakCaseIds);
			}
			if (QueueExecutionSummary.bHasCompletionGap
				|| QueueExecutionSummary.bHasOutstandingDeferredWork)
			{
				AppendSchedulePressureCaseIds(Snapshot.WeakCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.PersistentCoachWeakCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.DueCaseIds);
			}
			if (PrioritizedSchedulePressureCaseIds.Num() == 0)
			{
				AppendSchedulePressureCaseIds(Snapshot.WeakCaseIds);
				AppendSchedulePressureCaseIds(Snapshot.DueCaseIds);
			}
			Snapshot.SchedulePressureCaseIds = PrioritizedSchedulePressureCaseIds;

			if (Snapshot.SchedulePressureCaseIds.Num() > 0)
			{
				TArray<FString> WeakCaseIdsWithSchedulePressure;
				const auto AppendWeakCaseIdsWithSchedulePressure = [&WeakCaseIdsWithSchedulePressure](
					const TArray<FString>& SourceCaseIds)
				{
					for (const FString& CaseId : SourceCaseIds)
					{
						if (!CaseId.IsEmpty() && !WeakCaseIdsWithSchedulePressure.Contains(CaseId))
						{
							WeakCaseIdsWithSchedulePressure.Add(CaseId);
						}
					}
				};

				AppendWeakCaseIdsWithSchedulePressure(Snapshot.SchedulePressureCaseIds);
				AppendWeakCaseIdsWithSchedulePressure(Snapshot.WeakCaseIds);
				Snapshot.WeakCaseIds = WeakCaseIdsWithSchedulePressure;
			}

			Snapshot.bNeedsCoachIntervention = Snapshot.bNeedsCoachIntervention
				|| Snapshot.bNeedsScheduleFrictionRecovery;
			Snapshot.bNeedsCadenceRecovery = Snapshot.bNeedsCadenceRecovery
				|| QueueExecutionSummary.bHasOutstandingDeferredWork
				|| QueueExecutionSummary.bHasCompletionGap
				|| QueueExecutionSummary.bHasRepeatManualRescheduleFriction;

			if (bQueueHistoryPrefersFollowUp
				&& (QueueExecutionSummary.PromotedEventCount > 0
					|| QueueExecutionSummary.bHasBlockedFollowUpFriction
					|| QueueExecutionSummary.BlockedFollowUpEventCount > 0))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
				Snapshot.PreferredGuidanceSourceLabel = ExplicitFollowUpHandoffSignal > 0
					? (AcceptedAlignedTightPacketOutcomeTrustSignal
							> AcceptedAlignedBroadPacketOutcomeTrustSignal
						? HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::FollowUp,
							true,
							AcceptedAlignedTightPacketReliableCompositeSignal
								> AcceptedAlignedBroadPacketReliableCompositeSignal)
						: HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::FollowUp,
							ExplicitDeferredOverflowFollowUpHandoffSignal > 0,
							ExplicitDeferredFirstFollowUpHandoffSignal > 0
								|| ExplicitDeferredFirstQueuedHandoffSignal > 0
						))
					: TEXT("coach-memory-queue-follow-up");
			}
			else if (bQueueHistoryPrefersRecommended
				&& Snapshot.PreferredGuidanceLane != EHyperTwistTrainingCoachGuidanceLane::FollowUp
				&& (QueueExecutionSummary.PromotedEventCount > 0
					|| QueueExecutionSummary.CompletedEventCount > 0))
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				Snapshot.PreferredGuidanceSourceLabel = ExplicitRecommendedHandoffSignal > 0
					? (AcceptedAlignedBroadPacketOutcomeTrustSignal
							> AcceptedAlignedTightPacketOutcomeTrustSignal
						? HyperTwistTrainingRepositoryLibraryInternal::AcceptedAlignedPacketOutcomeCoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::Recommended,
							false,
							AcceptedAlignedBroadPacketReliableCompositeSignal
								> AcceptedAlignedTightPacketReliableCompositeSignal)
						: HyperTwistTrainingRepositoryLibraryInternal::CoachMemoryDashboardSourceLabel(
							EHyperTwistTrainingCoachHandoffKind::Recommended,
							ExplicitDeferredOverflowRecommendedHandoffSignal > 0
						))
					: TEXT("coach-memory-queue-recommended");
			}
		}
	}

	if (Snapshot.OverdueCaseIds.Num() >= 3)
	{
		Snapshot.bNeedsCoachIntervention = true;
	}
	Snapshot.bNeedsVarietyRotation = Profile.DeckCount > 1 && Profile.FavoriteDeckSessionShare >= 0.7f;
	Snapshot.bNeedsCadenceRecovery = Snapshot.bNeedsCadenceRecovery
		|| Profile.LastTrainingAtUtc.IsEmpty()
		|| HyperTwistTrainingRepositoryLibraryInternal::ComputeElapsedDays(
			Profile.LastTrainingAtUtc,
			Snapshot.ReferenceUtc
		) > 3.0;

	const bool bHasGenericPreferredGuidanceSource =
		Snapshot.PreferredGuidanceSourceLabel.IsEmpty()
		|| Snapshot.PreferredGuidanceSourceLabel == TEXT("coach-memory-default")
		|| Snapshot.PreferredGuidanceSourceLabel == TEXT("coach-memory-follow-up")
		|| Snapshot.PreferredGuidanceSourceLabel.StartsWith(TEXT("coach-memory-schedule-"));
	if (Snapshot.bHasBlockedFollowUpScheduleFriction
		|| Snapshot.ScheduleBlockedFollowUpEventCount > 0
		|| Snapshot.FollowUpReadyCoachSequenceCount > 0)
	{
		Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
		if (bHasGenericPreferredGuidanceSource)
		{
			Snapshot.PreferredGuidanceSourceLabel =
				Snapshot.bHasBlockedFollowUpScheduleFriction
				|| Snapshot.ScheduleBlockedFollowUpEventCount > 0
					? TEXT("coach-memory-schedule-follow-up")
					: TEXT("coach-memory-follow-up");
		}
	}
	else if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None)
	{
		Snapshot.PreferredGuidanceLane = Snapshot.bHasRepeatRecommendationPressure
			|| Snapshot.RecurringCoachCaseIds.Num() > 0
			? EHyperTwistTrainingCoachGuidanceLane::Recommended
			: EHyperTwistTrainingCoachGuidanceLane::FollowUp;
		if (bHasGenericPreferredGuidanceSource)
		{
			Snapshot.PreferredGuidanceSourceLabel = TEXT("coach-memory-default");
		}
	}
	if (Snapshot.PreferredQueueRecoveryAction == EHyperTwistTrainingQueueRecoveryAction::None
		&& Snapshot.bNeedsScheduleFrictionRecovery)
	{
		Snapshot.PreferredQueueRecoveryAction = Snapshot.bHasOutstandingDeferredScheduleWork
			&& !Snapshot.bHasQueueExecutionCompletionGap
			? EHyperTwistTrainingQueueRecoveryAction::PromoteDeferred
			: EHyperTwistTrainingQueueRecoveryAction::LaunchRecovery;
		Snapshot.PreferredQueueRecoveryActionSourceLabel = TEXT("coach-memory-schedule-default");
	}
	if (Snapshot.bNeedsScheduleFrictionRecovery)
	{
		const int32 ScheduleTighteningBias = FMath::Clamp(
			(Snapshot.bHasBlockedFollowUpScheduleFriction ? 2 : 0)
				+ (Snapshot.ScheduleBlockedFollowUpEventCount > 0 ? 1 : 0)
				+ (Snapshot.bHasOutstandingDeferredScheduleWork ? 1 : 0)
				+ (Snapshot.bHasQueueExecutionCompletionGap ? 1 : 0)
				+ (Snapshot.bHasRepeatManualScheduleFriction ? 1 : 0),
			1,
			4
		);
		const bool bPreferFollowUpScheduleRecovery =
			Snapshot.bHasBlockedFollowUpScheduleFriction
			|| Snapshot.ScheduleBlockedFollowUpEventCount > 0
			|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp;
		const bool bPreferRecommendedScheduleRecovery =
			!bPreferFollowUpScheduleRecovery
			&& (Snapshot.bHasQueueExecutionCompletionGap
				|| Snapshot.bHasOutstandingDeferredScheduleWork
				|| Snapshot.PreferredGuidanceLane
					== EHyperTwistTrainingCoachGuidanceLane::Recommended);
		const bool bHasGenericLaunchBudgetSource =
			Snapshot.PreferredLaunchBudgetSourceLabel.IsEmpty()
			|| Snapshot.PreferredLaunchBudgetSourceLabel.StartsWith(TEXT("coach-memory-schedule-"));

		Snapshot.PreferredLaunchBudgetBias =
			FMath::Min(Snapshot.PreferredLaunchBudgetBias, -ScheduleTighteningBias);
		if (bHasGenericLaunchBudgetSource)
		{
			Snapshot.PreferredLaunchBudgetSourceLabel = bPreferFollowUpScheduleRecovery
				? TEXT("coach-memory-schedule-follow-up-tightened-launch")
				: TEXT("coach-memory-schedule-tightened-launch");
		}

		if (bPreferFollowUpScheduleRecovery)
		{
			Snapshot.FollowUpGuidanceContinueBias += ScheduleTighteningBias;
			Snapshot.SuppressedPrimaryQueuePressureCount += ScheduleTighteningBias;
			Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::FollowUp;
			if (bHasGenericPreferredGuidanceSource)
			{
				Snapshot.PreferredGuidanceSourceLabel =
					Snapshot.bHasBlockedFollowUpScheduleFriction
					|| Snapshot.ScheduleBlockedFollowUpEventCount > 0
						? TEXT("coach-memory-schedule-follow-up")
						: TEXT("coach-memory-follow-up");
			}
		}
		else if (bPreferRecommendedScheduleRecovery)
		{
			const int32 RecommendedScheduleRecoveryBias = FMath::Max(
				1,
				ScheduleTighteningBias - (Snapshot.bHasArchiveAwareScheduleFriction ? 1 : 0)
			);
			Snapshot.RecommendedGuidanceContinueBias += RecommendedScheduleRecoveryBias;
			Snapshot.SuppressedFollowUpQueuePressureCount += RecommendedScheduleRecoveryBias;
			if (Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::None
				|| Snapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
				|| bHasGenericPreferredGuidanceSource)
			{
				Snapshot.PreferredGuidanceLane = EHyperTwistTrainingCoachGuidanceLane::Recommended;
				if (bHasGenericPreferredGuidanceSource)
				{
					Snapshot.PreferredGuidanceSourceLabel = TEXT("coach-memory-schedule-recommended");
				}
			}
		}
	}

	return Snapshot;
}

TArray<FHyperTwistTrainingMethodSegment> UHyperTwistTrainingRepositoryLibrary::DeriveLearnerMethodSegments(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	TArray<FHyperTwistTrainingMethodSegment> Segments;
	if (UserId.IsEmpty())
	{
		return Segments;
	}

	const FString ResolvedReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	const TArray<FHyperTwistContentPack> TrainingCatalog = UHyperTwistTrainingCatalogLibrary::MakePhase3TrainingCatalog();
	TMap<FString, HyperTwistTrainingRepositoryLibraryInternal::FMethodSegmentAggregate> AggregateBySegmentId;

	const auto EnsureAggregate = [&TrainingCatalog, &AggregateBySegmentId, &UserId, &ResolvedReferenceUtc](
		const FString& DeckId
	) -> HyperTwistTrainingRepositoryLibraryInternal::FMethodSegmentAggregate&
	{
		const FHyperTwistTrainingMethodDescriptor Descriptor =
			HyperTwistTrainingRepositoryLibraryInternal::DescribeDeckMethodOrFallback(TrainingCatalog, DeckId);
		HyperTwistTrainingRepositoryLibraryInternal::FMethodSegmentAggregate& Aggregate =
			AggregateBySegmentId.FindOrAdd(Descriptor.SegmentId);
		if (!Aggregate.Segment.MethodDescriptor.IsStructurallyValid())
		{
			Aggregate.Segment.UserId = UserId;
			Aggregate.Segment.ReferenceUtc = ResolvedReferenceUtc;
			Aggregate.Segment.MethodDescriptor = Descriptor;
		}
		Aggregate.Segment.DeckIds.AddUnique(DeckId);
		return Aggregate;
	};

	for (const FHyperTwistTrainingRunRecord& RunRecord : RepositoryState.RunRecords)
	{
		if (!RunRecord.IsStructurallyValid() || RunRecord.Session.UserId != UserId)
		{
			continue;
		}

		HyperTwistTrainingRepositoryLibraryInternal::FMethodSegmentAggregate& Aggregate =
			EnsureAggregate(RunRecord.Session.DeckId);
		Aggregate.Segment.SessionCount += 1;
		if (RunRecord.bCompleted)
		{
			Aggregate.Segment.CompletedSessionCount += 1;
		}

		Aggregate.Segment.AttemptCount += RunRecord.Summary.AttemptCount;
		Aggregate.Segment.SuccessCount += RunRecord.Summary.SuccessCount;
		Aggregate.Segment.FailureCount += RunRecord.Summary.FailureCount
			+ RunRecord.Summary.TimeoutCount
			+ RunRecord.Summary.DNFCount
			+ RunRecord.Summary.AbortedCount;
		Aggregate.SessionCountByMode.FindOrAdd(RunRecord.Session.Mode) += 1;

		if (RunRecord.Summary.AverageTotalTimeMs > 0)
		{
			const int32 TimedAttemptWeight = FMath::Max(1, RunRecord.Summary.CompletedAttemptCount);
			Aggregate.TotalTimeAccumulator += static_cast<int64>(RunRecord.Summary.AverageTotalTimeMs) * TimedAttemptWeight;
			Aggregate.TotalTimeCount += TimedAttemptWeight;
		}
		if (RunRecord.Summary.AverageRawSolveTimeMs > 0)
		{
			const int32 TimedAttemptWeight = FMath::Max(1, RunRecord.Summary.CompletedAttemptCount);
			Aggregate.RawTimeAccumulator += static_cast<int64>(RunRecord.Summary.AverageRawSolveTimeMs) * TimedAttemptWeight;
			Aggregate.RawTimeCount += TimedAttemptWeight;
		}

		const FString LastTrainingAtUtc = !RunRecord.LastUpdatedAtUtc.IsEmpty()
			? RunRecord.LastUpdatedAtUtc
			: RunRecord.Session.EndedAtUtc;
		if (Aggregate.Segment.LastTrainingAtUtc.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				LastTrainingAtUtc,
				Aggregate.Segment.LastTrainingAtUtc
			) > 0)
		{
			Aggregate.Segment.LastTrainingAtUtc = LastTrainingAtUtc;
		}
	}

	for (const FHyperTwistTrainingCaseLearnerState& LearnerState : RepositoryState.LearnerStates)
	{
		if (!LearnerState.IsStructurallyValid() || LearnerState.UserId != UserId)
		{
			continue;
		}

		HyperTwistTrainingRepositoryLibraryInternal::FMethodSegmentAggregate& Aggregate =
			EnsureAggregate(LearnerState.DeckId);
		Aggregate.CandidateStates.Add(LearnerState);
		Aggregate.Segment.TrackedCaseCount += 1;

		if (LearnerState.ReviewCount > 0)
		{
			if (LearnerState.StabilityDays >= HyperTwistTrainingRepositoryLibraryInternal::MatureStabilityDays)
			{
				Aggregate.Segment.MatureCaseCount += 1;
			}
			else
			{
				Aggregate.Segment.LearningCaseCount += 1;
			}
		}

		const bool bHasDueDate = !LearnerState.DueAtUtc.IsEmpty();
		const int32 DueCompare = bHasDueDate
			? HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(LearnerState.DueAtUtc, ResolvedReferenceUtc)
			: 0;
		if (!bHasDueDate || DueCompare <= 0)
		{
			Aggregate.Segment.DueCaseCount += 1;
			Aggregate.FocusScoreByDeck.FindOrAdd(LearnerState.DeckId) += 10;
		}
		if (bHasDueDate && DueCompare < 0)
		{
			Aggregate.Segment.OverdueCaseCount += 1;
			Aggregate.FocusScoreByDeck.FindOrAdd(LearnerState.DeckId) += 100;
		}
		Aggregate.FocusScoreByDeck.FindOrAdd(LearnerState.DeckId) += LearnerState.LapseCount;

		if (Aggregate.Segment.LastTrainingAtUtc.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				LearnerState.LastReviewedAtUtc,
				Aggregate.Segment.LastTrainingAtUtc
			) > 0)
		{
			Aggregate.Segment.LastTrainingAtUtc = LearnerState.LastReviewedAtUtc;
		}
	}

	for (TPair<FString, HyperTwistTrainingRepositoryLibraryInternal::FMethodSegmentAggregate>& Pair : AggregateBySegmentId)
	{
		HyperTwistTrainingRepositoryLibraryInternal::FMethodSegmentAggregate& Aggregate = Pair.Value;

		if (Aggregate.Segment.AttemptCount > 0)
		{
			Aggregate.Segment.SuccessRate = static_cast<float>(Aggregate.Segment.SuccessCount)
				/ static_cast<float>(Aggregate.Segment.AttemptCount);
		}
		if (Aggregate.TotalTimeCount > 0)
		{
			Aggregate.Segment.AverageTotalTimeMs = static_cast<int32>(Aggregate.TotalTimeAccumulator / Aggregate.TotalTimeCount);
		}
		if (Aggregate.RawTimeCount > 0)
		{
			Aggregate.Segment.AverageRawSolveTimeMs = static_cast<int32>(Aggregate.RawTimeAccumulator / Aggregate.RawTimeCount);
		}

		int32 BestModeCount = -1;
		for (const TPair<EHyperTwistTrainingDeliveryMode, int32>& ModePair : Aggregate.SessionCountByMode)
		{
			if (ModePair.Value > BestModeCount)
			{
				BestModeCount = ModePair.Value;
				Aggregate.Segment.PrimaryDeliveryMode = ModePair.Key;
			}
		}

		int32 BestFocusScore = -1;
		for (const TPair<FString, int32>& FocusPair : Aggregate.FocusScoreByDeck)
		{
			if (FocusPair.Value > BestFocusScore
				|| (FocusPair.Value == BestFocusScore
					&& (Aggregate.Segment.FocusDeckId.IsEmpty() || FocusPair.Key < Aggregate.Segment.FocusDeckId)))
			{
				BestFocusScore = FocusPair.Value;
				Aggregate.Segment.FocusDeckId = FocusPair.Key;
			}
		}

		Aggregate.CandidateStates.Sort([&ResolvedReferenceUtc](const FHyperTwistTrainingCaseLearnerState& Left, const FHyperTwistTrainingCaseLearnerState& Right)
		{
			const bool bLeftOverdue = !Left.DueAtUtc.IsEmpty() && Left.DueAtUtc < ResolvedReferenceUtc;
			const bool bRightOverdue = !Right.DueAtUtc.IsEmpty() && Right.DueAtUtc < ResolvedReferenceUtc;
			if (bLeftOverdue != bRightOverdue)
			{
				return bLeftOverdue;
			}
			if (Left.LapseCount != Right.LapseCount)
			{
				return Left.LapseCount > Right.LapseCount;
			}
			if (!FMath::IsNearlyEqual(Left.DifficultyScore, Right.DifficultyScore))
			{
				return Left.DifficultyScore > Right.DifficultyScore;
			}
			return Left.CaseId < Right.CaseId;
		});

		for (const FHyperTwistTrainingCaseLearnerState& CandidateState : Aggregate.CandidateStates)
		{
			if (Aggregate.Segment.FocusCaseIds.Num() >= 5)
			{
				break;
			}

			Aggregate.Segment.FocusCaseIds.AddUnique(CandidateState.CaseId);
		}

		Aggregate.Segment.bNeedsRecovery = Aggregate.Segment.OverdueCaseCount > 0
			|| Aggregate.Segment.DueCaseCount >= 3
			|| Aggregate.Segment.LearningCaseCount > Aggregate.Segment.MatureCaseCount;
		Aggregate.Segment.bNeedsCoachIntervention = Aggregate.Segment.OverdueCaseCount >= 2
			|| (Aggregate.Segment.AttemptCount >= 4 && Aggregate.Segment.SuccessRate < 0.5f);

		if (Aggregate.Segment.IsStructurallyValid())
		{
			Segments.Add(Aggregate.Segment);
		}
	}

	Segments.Sort([](const FHyperTwistTrainingMethodSegment& Left, const FHyperTwistTrainingMethodSegment& Right)
	{
		if (Left.OverdueCaseCount != Right.OverdueCaseCount)
		{
			return Left.OverdueCaseCount > Right.OverdueCaseCount;
		}
		if (Left.DueCaseCount != Right.DueCaseCount)
		{
			return Left.DueCaseCount > Right.DueCaseCount;
		}
		if (Left.SessionCount != Right.SessionCount)
		{
			return Left.SessionCount > Right.SessionCount;
		}
		return Left.MethodDescriptor.SegmentId < Right.MethodDescriptor.SegmentId;
	});

	return Segments;
}

TArray<FHyperTwistTrainingLearnerPreset> UHyperTwistTrainingRepositoryLibrary::DeriveLearnerPresets(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	TArray<FHyperTwistTrainingLearnerPreset> Presets;
	if (UserId.IsEmpty())
	{
		return Presets;
	}

	const FHyperTwistTrainingLearnerProfile Profile = DeriveLearnerProfile(RepositoryState, UserId, ReferenceUtc);
	const FHyperTwistTrainingCoachMemorySnapshot CoachMemory = DeriveCoachMemorySnapshot(RepositoryState, UserId, ReferenceUtc);
	const TArray<FHyperTwistTrainingMethodSegment> MethodSegments = DeriveLearnerMethodSegments(
		RepositoryState,
		UserId,
		Profile.ReferenceUtc
	);
	const auto ResolveMethodSegmentIdForDeck = [&MethodSegments](const FString& DeckId) -> FString
	{
		for (const FHyperTwistTrainingMethodSegment& MethodSegment : MethodSegments)
		{
			if (MethodSegment.DeckIds.Contains(DeckId))
			{
				return MethodSegment.MethodDescriptor.SegmentId;
			}
		}

		return FString();
	};

	if (!CoachMemory.FocusDeckId.IsEmpty())
	{
		FHyperTwistTrainingLearnerPreset RecoveryPreset;
		RecoveryPreset.UserId = UserId;
		RecoveryPreset.PresetId = TEXT("recovery-review");
		RecoveryPreset.Title = TEXT("Recovery Review");
		RecoveryPreset.FocusDeckId = CoachMemory.FocusDeckId;
		RecoveryPreset.MethodSegmentId = ResolveMethodSegmentIdForDeck(CoachMemory.FocusDeckId);
		RecoveryPreset.SuggestedMode = CoachMemory.bNeedsCoachIntervention
			? EHyperTwistTrainingDeliveryMode::CoachReviewed
			: EHyperTwistTrainingDeliveryMode::Timer;
		RecoveryPreset.SuggestedSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Spaced;
		RecoveryPreset.RecommendedCaseCount = FMath::Clamp(
			FMath::Max(CoachMemory.OverdueCaseIds.Num(), CoachMemory.DueCaseIds.Num()),
			3,
			6
		);
		RecoveryPreset.FocusCaseIds = CoachMemory.OverdueCaseIds.Num() > 0
			? CoachMemory.OverdueCaseIds
			: CoachMemory.WeakCaseIds;
		RecoveryPreset.GuidanceLabel = CoachMemory.bNeedsCoachIntervention
			? TEXT("coach-review-recovery")
			: TEXT("overdue-recovery");
		RecoveryPreset.bCoachReview = CoachMemory.bNeedsCoachIntervention;
		RecoveryPreset.bPreferShortReviewSet = true;
		Presets.Add(RecoveryPreset);
	}

	if (!CoachMemory.FocusDeckId.IsEmpty() && CoachMemory.bNeedsCadenceRecovery)
	{
		FHyperTwistTrainingLearnerPreset CadencePreset;
		CadencePreset.UserId = UserId;
		CadencePreset.PresetId = TEXT("cadence-recovery");
		CadencePreset.Title = TEXT("Cadence Recovery");
		CadencePreset.FocusDeckId = CoachMemory.FocusDeckId;
		CadencePreset.MethodSegmentId = ResolveMethodSegmentIdForDeck(CoachMemory.FocusDeckId);
		CadencePreset.SuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		CadencePreset.SuggestedSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		CadencePreset.RecommendedCaseCount = 4;
		CadencePreset.FocusCaseIds = CoachMemory.WeakCaseIds;
		CadencePreset.GuidanceLabel = TEXT("cadence-and-rhythm");
		CadencePreset.bCoachReview = false;
		CadencePreset.bPreferShortReviewSet = true;
		Presets.Add(CadencePreset);
	}

	FString RotationDeckId;
	for (const FString& RecoveryDeckId : CoachMemory.RecoveryDeckIds)
	{
		if (RecoveryDeckId != Profile.FavoriteDeckId)
		{
			RotationDeckId = RecoveryDeckId;
			break;
		}
	}
	if (!RotationDeckId.IsEmpty() && CoachMemory.bNeedsVarietyRotation)
	{
		FHyperTwistTrainingLearnerPreset VarietyPreset;
		VarietyPreset.UserId = UserId;
		VarietyPreset.PresetId = TEXT("variety-rotation");
		VarietyPreset.Title = TEXT("Variety Rotation");
		VarietyPreset.FocusDeckId = RotationDeckId;
		VarietyPreset.MethodSegmentId = ResolveMethodSegmentIdForDeck(RotationDeckId);
		VarietyPreset.SuggestedMode = EHyperTwistTrainingDeliveryMode::VirtualCube;
		VarietyPreset.SuggestedSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		VarietyPreset.RecommendedCaseCount = 4;
		VarietyPreset.GuidanceLabel = TEXT("variety-and-refresh");
		VarietyPreset.bCoachReview = false;
		VarietyPreset.bPreferShortReviewSet = false;
		Presets.Add(VarietyPreset);
	}

	if (Profile.TotalTrackedCaseCount > 0)
	{
		FHyperTwistTrainingLearnerPreset AccuracyPreset;
		AccuracyPreset.UserId = UserId;
		AccuracyPreset.PresetId = TEXT("accuracy-stabilizer");
		AccuracyPreset.Title = TEXT("Accuracy Stabilizer");
		AccuracyPreset.FocusDeckId = !CoachMemory.FocusDeckId.IsEmpty() ? CoachMemory.FocusDeckId : Profile.FavoriteDeckId;
		AccuracyPreset.MethodSegmentId = ResolveMethodSegmentIdForDeck(AccuracyPreset.FocusDeckId);
		AccuracyPreset.SuggestedMode = CoachMemory.bNeedsCoachIntervention
			? EHyperTwistTrainingDeliveryMode::RecognitionAssisted
			: EHyperTwistTrainingDeliveryMode::VirtualCube;
		AccuracyPreset.SuggestedSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		AccuracyPreset.RecommendedCaseCount = FMath::Clamp(Profile.LearningCaseCount > 0 ? 5 : 4, 4, 6);
		AccuracyPreset.FocusCaseIds = CoachMemory.WeakCaseIds;
		AccuracyPreset.GuidanceLabel = TEXT("accuracy-and-consistency");
		AccuracyPreset.bCoachReview = false;
		AccuracyPreset.bPreferShortReviewSet = false;
		Presets.Add(AccuracyPreset);
	}

	if (!Profile.FavoriteDeckId.IsEmpty() && Profile.SuccessRate >= 0.8f)
	{
		FHyperTwistTrainingLearnerPreset SpeedPreset;
		SpeedPreset.UserId = UserId;
		SpeedPreset.PresetId = TEXT("speed-consolidation");
		SpeedPreset.Title = TEXT("Speed Consolidation");
		SpeedPreset.FocusDeckId = Profile.FavoriteDeckId;
		SpeedPreset.MethodSegmentId = ResolveMethodSegmentIdForDeck(Profile.FavoriteDeckId);
		SpeedPreset.SuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		SpeedPreset.SuggestedSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		SpeedPreset.RecommendedCaseCount = 6;
		SpeedPreset.GuidanceLabel = TEXT("speed-and-confidence");
		SpeedPreset.bCoachReview = false;
		SpeedPreset.bPreferShortReviewSet = false;
		Presets.Add(SpeedPreset);
	}

	return Presets;
}

TArray<FHyperTwistTrainingSessionTemplate> UHyperTwistTrainingRepositoryLibrary::DeriveTrainingSessionTemplates(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	TArray<FHyperTwistTrainingSessionTemplate> Templates;
	if (UserId.IsEmpty())
	{
		return Templates;
	}

	const FString ResolvedReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	const FHyperTwistTrainingCoachMemorySnapshot CoachMemory = DeriveCoachMemorySnapshot(
		RepositoryState,
		UserId,
		ResolvedReferenceUtc
	);
	const TArray<FHyperTwistTrainingLearnerPreset> Presets = DeriveLearnerPresets(
		RepositoryState,
		UserId,
		ResolvedReferenceUtc
	);

	if (CoachMemory.PendingReviewPlanIds.Num() > 0 && !CoachMemory.FocusDeckId.IsEmpty())
	{
		FHyperTwistTrainingSessionTemplate ReviewPlanTemplate;
		ReviewPlanTemplate.UserId = UserId;
		ReviewPlanTemplate.TemplateId = TEXT("review-plan-template");
		ReviewPlanTemplate.Title = TEXT("Resume Review Plan");
		ReviewPlanTemplate.TemplateKind = CoachMemory.bNeedsCoachIntervention
			? EHyperTwistTrainingSessionTemplateKind::Coach
			: EHyperTwistTrainingSessionTemplateKind::ReviewPlan;
		ReviewPlanTemplate.FocusDeckId = CoachMemory.FocusDeckId;
		ReviewPlanTemplate.MethodSegmentId = CoachMemory.FocusMethodSegmentId;
		ReviewPlanTemplate.SuggestedMode = CoachMemory.bNeedsCoachIntervention
			? EHyperTwistTrainingDeliveryMode::CoachReviewed
			: EHyperTwistTrainingDeliveryMode::Timer;
		ReviewPlanTemplate.SuggestedSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Spaced;
		ReviewPlanTemplate.RecommendedCaseCount = FMath::Clamp(CoachMemory.DueCaseIds.Num(), 3, 6);
		ReviewPlanTemplate.FocusCaseIds = CoachMemory.DueCaseIds.Num() > 0 ? CoachMemory.DueCaseIds : CoachMemory.WeakCaseIds;
		ReviewPlanTemplate.GuidanceLabel = CoachMemory.bNeedsCoachIntervention
			? TEXT("resume-coach-review-plan")
			: TEXT("resume-review-plan");
		ReviewPlanTemplate.SourceReviewPlanId = CoachMemory.LastReviewPlanId;
		ReviewPlanTemplate.bPreferReviewRun = true;
		ReviewPlanTemplate.bCoachReview = CoachMemory.bNeedsCoachIntervention;
		ReviewPlanTemplate.bPreferShortReviewSet = true;
		Templates.Add(ReviewPlanTemplate);
	}

	for (const FHyperTwistTrainingLearnerPreset& Preset : Presets)
	{
		if (Preset.FocusDeckId.IsEmpty())
		{
			continue;
		}

		FHyperTwistTrainingSessionTemplate Template;
		Template.UserId = UserId;
		Template.TemplateId = FString::Printf(TEXT("template_%s"), *Preset.PresetId);
		Template.Title = Preset.Title;
		Template.FocusDeckId = Preset.FocusDeckId;
		Template.MethodSegmentId = Preset.MethodSegmentId;
		Template.SuggestedMode = Preset.SuggestedMode;
		Template.SuggestedSelectionPolicy = Preset.SuggestedSelectionPolicy;
		Template.RecommendedCaseCount = FMath::Max(1, Preset.RecommendedCaseCount);
		Template.FocusCaseIds = Preset.FocusCaseIds;
		Template.GuidanceLabel = Preset.GuidanceLabel;
		Template.SourcePresetId = Preset.PresetId;
		Template.bPreferReviewRun = Preset.PresetId == TEXT("recovery-review");
		Template.bCoachReview = Preset.bCoachReview;
		Template.bPreferShortReviewSet = Preset.bPreferShortReviewSet;

		if (Preset.PresetId == TEXT("recovery-review"))
		{
			Template.TemplateKind = Preset.bCoachReview
				? EHyperTwistTrainingSessionTemplateKind::Coach
				: EHyperTwistTrainingSessionTemplateKind::Recovery;
		}
		else if (Preset.PresetId == TEXT("cadence-recovery"))
		{
			Template.TemplateKind = EHyperTwistTrainingSessionTemplateKind::Recovery;
		}
		else if (Preset.PresetId == TEXT("variety-rotation"))
		{
			Template.TemplateKind = EHyperTwistTrainingSessionTemplateKind::Recovery;
		}
		else if (Preset.PresetId == TEXT("accuracy-stabilizer"))
		{
			Template.TemplateKind = EHyperTwistTrainingSessionTemplateKind::Accuracy;
		}
		else if (Preset.PresetId == TEXT("speed-consolidation"))
		{
			Template.TemplateKind = EHyperTwistTrainingSessionTemplateKind::Speed;
		}
		else
		{
			Template.TemplateKind = EHyperTwistTrainingSessionTemplateKind::Recovery;
		}

		if (Template.IsStructurallyValid())
		{
			Templates.Add(Template);
		}
	}

	return Templates;
}

TArray<FHyperTwistTrainingSessionTemplate> UHyperTwistTrainingRepositoryLibrary::ListStoredTrainingSessionTemplates(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId
)
{
	TArray<FHyperTwistTrainingSessionTemplate> StoredTemplates;
	if (UserId.IsEmpty())
	{
		return StoredTemplates;
	}

	for (const FHyperTwistTrainingSessionTemplate& SessionTemplate : RepositoryState.StoredSessionTemplates)
	{
		if (SessionTemplate.UserId == UserId && SessionTemplate.IsStructurallyValid())
		{
			StoredTemplates.Add(SessionTemplate);
		}
	}

	StoredTemplates.Sort([](const FHyperTwistTrainingSessionTemplate& Left, const FHyperTwistTrainingSessionTemplate& Right)
	{
		if (Left.bUserCreated != Right.bUserCreated)
		{
			return Left.bUserCreated && !Right.bUserCreated;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastUpdatedAtUtc,
			Right.LastUpdatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.TemplateId < Right.TemplateId;
	});
	return StoredTemplates;
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetStoredTrainingSessionTemplate(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& TemplateId,
	FHyperTwistTrainingSessionTemplate& OutTemplate
)
{
	OutTemplate = FHyperTwistTrainingSessionTemplate();
	if (UserId.IsEmpty() || TemplateId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingSessionTemplate* MatchingTemplate = RepositoryState.StoredSessionTemplates.FindByPredicate(
		[&UserId, &TemplateId](const FHyperTwistTrainingSessionTemplate& Candidate)
		{
			return Candidate.UserId == UserId
				&& Candidate.TemplateId == TemplateId
				&& Candidate.IsStructurallyValid();
		}
	);
	if (MatchingTemplate == nullptr)
	{
		return false;
	}

	OutTemplate = *MatchingTemplate;
	return true;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertStoredTrainingSessionTemplate(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingSessionTemplate& SessionTemplate
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	if (!SessionTemplate.IsStructurallyValid())
	{
		return UpdatedRepositoryState;
	}

	const FHyperTwistTrainingSessionTemplate NormalizedTemplate =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeStoredTemplate(SessionTemplate);
	FHyperTwistTrainingSessionTemplate* ExistingTemplate = UpdatedRepositoryState.StoredSessionTemplates.FindByPredicate(
		[&NormalizedTemplate](const FHyperTwistTrainingSessionTemplate& Candidate)
		{
			return Candidate.UserId == NormalizedTemplate.UserId
				&& Candidate.TemplateId == NormalizedTemplate.TemplateId;
		}
	);
	if (ExistingTemplate != nullptr)
	{
		*ExistingTemplate = NormalizedTemplate;
	}
	else
	{
		UpdatedRepositoryState.StoredSessionTemplates.Add(NormalizedTemplate);
	}

	return UpdatedRepositoryState;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::RemoveStoredTrainingSessionTemplate(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& TemplateId
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	if (UserId.IsEmpty() || TemplateId.IsEmpty())
	{
		return UpdatedRepositoryState;
	}

	UpdatedRepositoryState.StoredSessionTemplates.RemoveAll(
		[&UserId, &TemplateId](const FHyperTwistTrainingSessionTemplate& Candidate)
		{
			return Candidate.UserId == UserId && Candidate.TemplateId == TemplateId;
		}
	);
	return UpdatedRepositoryState;
}

TArray<FHyperTwistTrainingSessionTemplate> UHyperTwistTrainingRepositoryLibrary::MergeTrainingSessionTemplates(
	const TArray<FHyperTwistTrainingSessionTemplate>& DerivedTemplates,
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId
)
{
	TArray<FHyperTwistTrainingSessionTemplate> EffectiveTemplates;
	TMap<FString, FHyperTwistTrainingSessionTemplate> StoredTemplateById;
	for (const FHyperTwistTrainingSessionTemplate& StoredTemplate : ListStoredTrainingSessionTemplates(RepositoryState, UserId))
	{
		StoredTemplateById.Add(StoredTemplate.TemplateId, StoredTemplate);
	}

	for (const FHyperTwistTrainingSessionTemplate& DerivedTemplate : DerivedTemplates)
	{
		if (!DerivedTemplate.IsStructurallyValid())
		{
			continue;
		}

		if (const FHyperTwistTrainingSessionTemplate* StoredTemplate = StoredTemplateById.Find(DerivedTemplate.TemplateId))
		{
			EffectiveTemplates.Add(*StoredTemplate);
			StoredTemplateById.Remove(DerivedTemplate.TemplateId);
		}
		else
		{
			EffectiveTemplates.Add(DerivedTemplate);
		}
	}

	TArray<FHyperTwistTrainingSessionTemplate> RemainingStoredTemplates;
	StoredTemplateById.GenerateValueArray(RemainingStoredTemplates);
	RemainingStoredTemplates.Sort([](const FHyperTwistTrainingSessionTemplate& Left, const FHyperTwistTrainingSessionTemplate& Right)
	{
		if (Left.bUserCreated != Right.bUserCreated)
		{
			return Left.bUserCreated && !Right.bUserCreated;
		}

		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastUpdatedAtUtc,
			Right.LastUpdatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.TemplateId < Right.TemplateId;
	});
	EffectiveTemplates.Append(RemainingStoredTemplates);
	return EffectiveTemplates;
}

FHyperTwistTrainingCoachActionPlan UHyperTwistTrainingRepositoryLibrary::BuildCoachActionPlan(
	const FHyperTwistCoachBrief& CoachBrief,
	const FHyperTwistTrainingCoachMemorySnapshot& CoachMemorySnapshot,
	const FString& PlanId,
	const FString& ReferenceUtc,
	const int32 RequestedLaunchCaseCount,
	const int32 PlannedLaunchCaseCount,
	const FString& LaunchBudgetReasonLine,
	const TArray<FString>& LaunchedCaseIds
)
{
	FHyperTwistTrainingCoachActionPlan ActionPlan;
	if (CoachBrief.UserId.IsEmpty() || PlanId.IsEmpty())
	{
		return ActionPlan;
	}

	ActionPlan.PlanId = PlanId;
	ActionPlan.UserId = CoachBrief.UserId;
	ActionPlan.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
		!ReferenceUtc.IsEmpty() ? ReferenceUtc : CoachBrief.ReferenceUtc
	);
	ActionPlan.SourceSessionId = CoachBrief.TrainingSessionId;
	ActionPlan.SourceReviewPlanId = CoachBrief.SourceReviewPlanId;
	ActionPlan.ParentPlanId = CoachBrief.CarryForwardPlanId;
	ActionPlan.RootPlanId = !CoachBrief.RootPlanId.IsEmpty()
		? CoachBrief.RootPlanId
		: (!CoachBrief.CarryForwardPlanId.IsEmpty() ? CoachBrief.CarryForwardPlanId : PlanId);
	ActionPlan.FocusDeckId = CoachBrief.FocusDeckId;
	ActionPlan.FocusMethodSegmentId = CoachBrief.FocusMethodSegmentId;
	ActionPlan.FocusLaneLabel = StaticEnum<EHyperTwistCoachFocusLane>()->GetNameStringByValue(
		static_cast<int64>(CoachBrief.FocusLane)
	);
	ActionPlan.PriorityLabel = StaticEnum<EHyperTwistCoachPriority>()->GetNameStringByValue(
		static_cast<int64>(CoachBrief.Priority)
	);
	ActionPlan.PriorityScore = CoachBrief.PriorityScore;
	ActionPlan.Headline = CoachBrief.Headline;
	ActionPlan.PrimaryActionLabel = CoachBrief.PrimaryActionLabel;
	ActionPlan.SuggestedMode = CoachBrief.SuggestedMode;
	ActionPlan.SuggestedSelectionPolicy = CoachBrief.SuggestedSelectionPolicy;
	HyperTwistTrainingRepositoryLibraryInternal::ResolveCoachActionPlanPreferenceDefaults(
		CoachBrief,
		CoachMemorySnapshot,
		ActionPlan.SuggestedMode,
		ActionPlan.SuggestedSelectionPolicy
	);
	ActionPlan.PreferredGuidanceLane = CoachMemorySnapshot.PreferredGuidanceLane;
	ActionPlan.PreferredGuidanceSourceLabel = CoachMemorySnapshot.PreferredGuidanceSourceLabel;
	ActionPlan.PreferredCoachHandoffKind = CoachMemorySnapshot.PreferredCoachHandoffKind;
	ActionPlan.PreferredCoachHandoffSourceLabel = CoachMemorySnapshot.PreferredCoachHandoffSourceLabel;
	ActionPlan.RequestedLaunchCaseCount = RequestedLaunchCaseCount > 0
		? RequestedLaunchCaseCount
		: FMath::Max(1, CoachBrief.FocusCaseIds.Num());
	ActionPlan.PlannedLaunchCaseCount = PlannedLaunchCaseCount > 0
		? PlannedLaunchCaseCount
		: ActionPlan.RequestedLaunchCaseCount;
	ActionPlan.FocusCaseIds = HyperTwistTrainingRepositoryLibraryInternal::ResolveCoachActionPlanFocusCaseIds(
		CoachBrief,
		LaunchedCaseIds,
		ActionPlan.PlannedLaunchCaseCount
	);
	if (ActionPlan.FocusCaseIds.Num() > 0)
	{
		ActionPlan.PlannedLaunchCaseCount = ActionPlan.FocusCaseIds.Num();
	}
	for (const FString& OriginalFocusCaseId : HyperTwistTrainingRepositoryLibraryInternal::DeduplicateCaseIds(
		CoachBrief.FocusCaseIds))
	{
		if (!ActionPlan.FocusCaseIds.Contains(OriginalFocusCaseId))
		{
			ActionPlan.DeferredLaunchCaseIds.Add(OriginalFocusCaseId);
		}
	}
	ActionPlan.LaunchBudgetReasonLine = LaunchBudgetReasonLine;
	ActionPlan.bBroadenedLaunchBudget =
		ActionPlan.PlannedLaunchCaseCount > ActionPlan.RequestedLaunchCaseCount
		|| HyperTwistTrainingRepositoryLibraryInternal::ContainsLaunchBudgetBroadeningHint(
			ActionPlan.LaunchBudgetReasonLine);
	ActionPlan.bTightenedLaunchBudget =
		ActionPlan.PlannedLaunchCaseCount < ActionPlan.RequestedLaunchCaseCount
		|| HyperTwistTrainingRepositoryLibraryInternal::ContainsLaunchBudgetTighteningHint(
			ActionPlan.LaunchBudgetReasonLine);
	if (ActionPlan.FocusCaseIds.Num() == 0)
	{
		ActionPlan.FocusCaseIds = CoachBrief.FocusCaseIds;
	}
	ActionPlan.PlanState = EHyperTwistTrainingCoachActionPlanState::Draft;
	ActionPlan.FollowUpDepth = FMath::Max(0, CoachBrief.FollowUpDepth);
	ActionPlan.CreatedAtUtc = ActionPlan.ReferenceUtc;
	ActionPlan.bNeedsCoachReview = CoachBrief.bNeedsCoachReview;
	ActionPlan.bNeedsCadenceRecovery = CoachBrief.bNeedsCadenceRecovery;
	ActionPlan.bNeedsVarietyRotation = CoachBrief.bNeedsVarietyRotation;
	ActionPlan.bPreferRecognitionReplayReview = CoachBrief.bPreferRecognitionReplayReview;

	for (int32 Index = 0; Index < ActionPlan.FocusCaseIds.Num(); ++Index)
	{
		FHyperTwistTrainingCoachActionPlanEntry Entry;
		Entry.ActionId = FString::Printf(TEXT("%s_entry_%02d"), *PlanId, Index + 1);
		Entry.CaseId = ActionPlan.FocusCaseIds[Index];
		Entry.DeckId = CoachBrief.FocusDeckId;
		Entry.MethodSegmentId = CoachBrief.FocusMethodSegmentId;
		Entry.ActionLabel = CoachBrief.PrimaryActionLabel;
		Entry.Headline = CoachBrief.Headline;
		Entry.PriorityScore = CoachBrief.PriorityScore;
		Entry.SuggestedMode = ActionPlan.SuggestedMode;
		Entry.SuggestedSelectionPolicy = ActionPlan.SuggestedSelectionPolicy;
		Entry.bPreferRecognitionReplayReview = CoachBrief.bPreferRecognitionReplayReview;
		if (Entry.IsStructurallyValid())
		{
			ActionPlan.Entries.Add(Entry);
		}
	}

	if (ActionPlan.Entries.Num() == 0)
	{
		FHyperTwistTrainingCoachActionPlanEntry Entry;
		Entry.ActionId = FString::Printf(TEXT("%s_entry_01"), *PlanId);
		Entry.CaseId = TEXT("coach-generic");
		Entry.DeckId = CoachBrief.FocusDeckId;
		Entry.MethodSegmentId = CoachBrief.FocusMethodSegmentId;
		Entry.ActionLabel = CoachBrief.PrimaryActionLabel.IsEmpty()
			? TEXT("coach-focus")
			: CoachBrief.PrimaryActionLabel;
		Entry.Headline = CoachBrief.Headline;
		Entry.PriorityScore = CoachBrief.PriorityScore;
		Entry.SuggestedMode = ActionPlan.SuggestedMode;
		Entry.SuggestedSelectionPolicy = ActionPlan.SuggestedSelectionPolicy;
		Entry.bPreferRecognitionReplayReview = CoachBrief.bPreferRecognitionReplayReview;
		ActionPlan.Entries.Add(Entry);
	}

	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
}

FHyperTwistTrainingCoachActionPlan UHyperTwistTrainingRepositoryLibrary::ActivateCoachActionPlan(
	const FHyperTwistTrainingCoachActionPlan& ActionPlan,
	const FString& TrainingSessionId,
	const FString& StartedAtUtc
)
{
	FHyperTwistTrainingCoachActionPlan UpdatedPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
	if (!UpdatedPlan.IsStructurallyValid())
	{
		return UpdatedPlan;
	}

	UpdatedPlan.PlanState = EHyperTwistTrainingCoachActionPlanState::Active;
	UpdatedPlan.SourceSessionId = !TrainingSessionId.IsEmpty() ? TrainingSessionId : UpdatedPlan.SourceSessionId;
	UpdatedPlan.StartedAtUtc = !StartedAtUtc.IsEmpty()
		? StartedAtUtc
		: HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(UpdatedPlan.ReferenceUtc);
	return UpdatedPlan;
}

FHyperTwistTrainingCoachActionPlan UHyperTwistTrainingRepositoryLibrary::FinalizeCoachActionPlan(
	const FHyperTwistTrainingCoachActionPlan& ActionPlan,
	const FHyperTwistTrainingSession& Session,
	bool bAbortPlan
)
{
	FHyperTwistTrainingCoachActionPlan UpdatedPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
	if (!UpdatedPlan.IsStructurallyValid())
	{
		return UpdatedPlan;
	}

	UpdatedPlan.SourceSessionId = !Session.TrainingSessionId.IsEmpty()
		? Session.TrainingSessionId
		: UpdatedPlan.SourceSessionId;
	UpdatedPlan.CompletedAtUtc = !Session.EndedAtUtc.IsEmpty()
		? Session.EndedAtUtc
		: HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(UpdatedPlan.ReferenceUtc);
	UpdatedPlan.PlanState = bAbortPlan || Session.SessionState == EHyperTwistTrainingSessionState::Aborted
		? EHyperTwistTrainingCoachActionPlanState::Aborted
		: EHyperTwistTrainingCoachActionPlanState::Completed;
	if (UpdatedPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Completed)
	{
		for (FHyperTwistTrainingCoachActionPlanEntry& Entry : UpdatedPlan.Entries)
		{
			Entry.bCompleted = true;
		}
	}

	return UpdatedPlan;
}

TArray<FHyperTwistTrainingCoachActionPlan> UHyperTwistTrainingRepositoryLibrary::ListCoachActionPlansForUser(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId
)
{
	TArray<FHyperTwistTrainingCoachActionPlan> ActionPlans;
	if (UserId.IsEmpty())
	{
		return ActionPlans;
	}

	for (const FHyperTwistTrainingCoachActionPlan& ActionPlan : RepositoryState.StoredCoachActionPlans)
	{
		if (ActionPlan.UserId == UserId && ActionPlan.IsStructurallyValid())
		{
			ActionPlans.Add(ActionPlan);
		}
	}

	ActionPlans.Sort([](const FHyperTwistTrainingCoachActionPlan& Left, const FHyperTwistTrainingCoachActionPlan& Right)
	{
		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.CreatedAtUtc,
			Right.CreatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.PlanId < Right.PlanId;
	});
	return ActionPlans;
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetCoachActionPlan(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& PlanId,
	FHyperTwistTrainingCoachActionPlan& OutActionPlan
)
{
	OutActionPlan = FHyperTwistTrainingCoachActionPlan();
	if (PlanId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingCoachActionPlan* MatchingPlan =
		RepositoryState.StoredCoachActionPlans.FindByPredicate(
			[&PlanId](const FHyperTwistTrainingCoachActionPlan& Candidate)
			{
				return Candidate.PlanId == PlanId && Candidate.IsStructurallyValid();
			}
		);
	if (MatchingPlan == nullptr)
	{
		return false;
	}

	OutActionPlan = *MatchingPlan;
	return true;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertCoachActionPlan(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingCoachActionPlan& ActionPlan
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
	if (!NormalizedPlan.IsStructurallyValid())
	{
		return UpdatedRepositoryState;
	}

	FHyperTwistTrainingCoachActionPlan* ExistingPlan =
		UpdatedRepositoryState.StoredCoachActionPlans.FindByPredicate(
			[&NormalizedPlan](const FHyperTwistTrainingCoachActionPlan& Candidate)
			{
				return Candidate.UserId == NormalizedPlan.UserId
					&& Candidate.PlanId == NormalizedPlan.PlanId;
			}
		);
	if (ExistingPlan != nullptr)
	{
		*ExistingPlan = NormalizedPlan;
	}
	else
	{
		UpdatedRepositoryState.StoredCoachActionPlans.Add(NormalizedPlan);
	}

	return UpdatedRepositoryState;
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRepositoryLibrary::BuildCoachSessionQueueState(
	const FHyperTwistCoachSessionQueueSummary& QueueSummary,
	const FString& QueueId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachSessionQueueState QueueState;
	if (!QueueSummary.IsStructurallyValid())
	{
		return QueueState;
	}

	QueueState.QueueId = QueueId.IsEmpty() ? TEXT("coach_queue_active") : QueueId;
	QueueState.UserId = QueueSummary.UserId;
	QueueState.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
		ReferenceUtc.IsEmpty() ? QueueSummary.ReferenceUtc : ReferenceUtc
	);
	QueueState.LastUpdatedAtUtc = QueueState.ReferenceUtc;
	QueueState.FocusDeckId = QueueSummary.FocusDeckId;
	QueueState.FocusMethodSegmentId = QueueSummary.FocusMethodSegmentId;
	QueueState.PrimaryQueueLabel = QueueSummary.PrimaryQueueLabel;
	QueueState.NextQueueLabel = QueueSummary.NextQueueLabel;
	QueueState.bHasImmediateQueue = QueueSummary.bHasImmediateQueue;
	QueueState.bNeedsArchiveAwareSequencing = QueueSummary.bNeedsArchiveAwareSequencing;

	for (const FHyperTwistCoachSessionQueueEntry& SummaryEntry : QueueSummary.Entries)
	{
		FHyperTwistTrainingCoachSessionQueueStateEntry QueueEntry;
		QueueEntry.EntryId = SummaryEntry.EntryId;
		QueueEntry.SourceLabel = SummaryEntry.SourceLabel;
		QueueEntry.SourceBriefTrainingSessionId = SummaryEntry.SourceBriefTrainingSessionId;
		QueueEntry.SourceReviewPlanId = SummaryEntry.SourceReviewPlanId;
		QueueEntry.CarryForwardPlanId = SummaryEntry.CarryForwardPlanId;
		QueueEntry.RootPlanId = SummaryEntry.RootPlanId;
		QueueEntry.FollowUpDepth = FMath::Max(0, SummaryEntry.FollowUpDepth);
		QueueEntry.SlotIndex = SummaryEntry.SlotIndex;
		QueueEntry.PriorityLabel = StaticEnum<EHyperTwistCoachPriority>()->GetNameStringByValue(
			static_cast<int64>(SummaryEntry.Priority)
		);
		QueueEntry.PriorityScore = SummaryEntry.PriorityScore;
		QueueEntry.FocusLaneLabel = StaticEnum<EHyperTwistCoachFocusLane>()->GetNameStringByValue(
			static_cast<int64>(SummaryEntry.FocusLane)
		);
		QueueEntry.Headline = SummaryEntry.Headline;
		QueueEntry.PrimaryActionLabel = SummaryEntry.PrimaryActionLabel;
		QueueEntry.SuggestedMode = SummaryEntry.SuggestedMode;
		QueueEntry.SuggestedSelectionPolicy = SummaryEntry.SuggestedSelectionPolicy;
		QueueEntry.FocusDeckId = SummaryEntry.FocusDeckId;
		QueueEntry.FocusMethodSegmentId = SummaryEntry.FocusMethodSegmentId;
		QueueEntry.FocusCaseIds = SummaryEntry.FocusCaseIds;
		QueueEntry.DeferredLaunchCaseCount = FMath::Max(0, SummaryEntry.DeferredLaunchCaseCount);
		QueueEntry.bNeedsDeferredLaunchRecovery = SummaryEntry.bNeedsDeferredLaunchRecovery;
		QueueEntry.bHasTightenedLaunchOverflow = SummaryEntry.bHasTightenedLaunchOverflow;
		QueueEntry.bRequiresFollowUp = SummaryEntry.bRequiresFollowUp;
		QueueEntry.bRequiresArchiveRetentionTuning = SummaryEntry.bRequiresArchiveRetentionTuning;
		QueueEntry.bNeedsCoachReview = SummaryEntry.bNeedsCoachReview;
		QueueEntry.bNeedsCadenceRecovery = SummaryEntry.bNeedsCadenceRecovery;
		QueueEntry.bNeedsVarietyRotation = SummaryEntry.bNeedsVarietyRotation;
		QueueEntry.bPreferRecognitionReplayReview = SummaryEntry.bPreferRecognitionReplayReview;
		QueueEntry.bPinned = QueueEntry.bRequiresFollowUp || QueueEntry.bRequiresArchiveRetentionTuning;
		QueueEntry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
		QueueEntry.WorkFingerprint =
			HyperTwistTrainingRepositoryLibraryInternal::MakeCoachSessionQueueEntryFingerprint(QueueEntry);
		QueueState.Entries.Add(QueueEntry);
	}

	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRepositoryLibrary::ResolveCoachSessionQueueState(
	const FHyperTwistTrainingCoachSessionQueueState& ExistingQueueState,
	const FHyperTwistCoachSessionQueueSummary& QueueSummary,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachSessionQueueState ResolvedQueueState = BuildCoachSessionQueueState(
		QueueSummary,
		ExistingQueueState.QueueId,
		ReferenceUtc
	);
	if (!ResolvedQueueState.IsStructurallyValid() || !ExistingQueueState.IsStructurallyValid())
	{
		return ResolvedQueueState;
	}

	for (FHyperTwistTrainingCoachSessionQueueStateEntry& QueueEntry : ResolvedQueueState.Entries)
	{
		const FHyperTwistTrainingCoachSessionQueueStateEntry* ExistingEntry =
			ExistingQueueState.Entries.FindByPredicate(
				[&QueueEntry](const FHyperTwistTrainingCoachSessionQueueStateEntry& Candidate)
				{
					return Candidate.EntryId == QueueEntry.EntryId
						&& Candidate.WorkFingerprint == QueueEntry.WorkFingerprint
						&& Candidate.IsStructurallyValid();
				}
			);
		if (ExistingEntry == nullptr)
		{
			continue;
		}

		QueueEntry.EntryState = ExistingEntry->EntryState;
		QueueEntry.SourceTrainingSessionId = ExistingEntry->SourceTrainingSessionId;
		QueueEntry.ScheduledAtUtc = ExistingEntry->ScheduledAtUtc;
		QueueEntry.DeferredUntilUtc = ExistingEntry->DeferredUntilUtc;
		QueueEntry.DeferredAtUtc = ExistingEntry->DeferredAtUtc;
		QueueEntry.DeferralReasonLabel = ExistingEntry->DeferralReasonLabel;
		QueueEntry.StartedAtUtc = ExistingEntry->StartedAtUtc;
		QueueEntry.CompletedAtUtc = ExistingEntry->CompletedAtUtc;
		QueueEntry.RescheduleCount = ExistingEntry->RescheduleCount;
		QueueEntry.bPinned = QueueEntry.bPinned || ExistingEntry->bPinned;
		QueueEntry.bCanStartImmediately = ExistingEntry->bCanStartImmediately;
		QueueEntry.bWasManuallyRescheduled = ExistingEntry->bWasManuallyRescheduled;
	}

	ResolvedQueueState.LastUpdatedAtUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
		ReferenceUtc.IsEmpty() ? ResolvedQueueState.ReferenceUtc : ReferenceUtc
	);
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(ResolvedQueueState);
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRepositoryLibrary::StartCoachSessionQueueEntryBySourceLabel(
	const FHyperTwistTrainingCoachSessionQueueState& QueueState,
	const FString& SourceLabel,
	const FString& TrainingSessionId,
	const FString& StartedAtUtc,
	const FString& StartActionSourceLabel
)
{
	FHyperTwistTrainingCoachSessionQueueState UpdatedQueueState =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
	if (!UpdatedQueueState.IsStructurallyValid() || SourceLabel.IsEmpty())
	{
		return UpdatedQueueState;
	}

	const FString ResolvedStartedAtUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(StartedAtUtc);
	int32 ActivatedIndex = INDEX_NONE;
	for (int32 EntryIndex = 0; EntryIndex < UpdatedQueueState.Entries.Num(); ++EntryIndex)
	{
		const FHyperTwistTrainingCoachSessionQueueStateEntry& Entry = UpdatedQueueState.Entries[EntryIndex];
		if (Entry.SourceLabel == SourceLabel
			&& Entry.EntryState != EHyperTwistTrainingCoachSessionQueueEntryState::Deferred
			&& !HyperTwistTrainingRepositoryLibraryInternal::IsTerminalCoachQueueEntryState(Entry.EntryState))
		{
			ActivatedIndex = EntryIndex;
			break;
		}
	}
	if (ActivatedIndex == INDEX_NONE)
	{
		return UpdatedQueueState;
	}

	for (FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : UpdatedQueueState.Entries)
	{
		if (Entry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress)
		{
			Entry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
			Entry.SourceTrainingSessionId.Reset();
			Entry.StartActionSourceLabel.Reset();
			Entry.StartedAtUtc.Reset();
			Entry.bCanStartImmediately = false;
		}
	}

	FHyperTwistTrainingCoachSessionQueueStateEntry& ActiveEntry =
		UpdatedQueueState.Entries[ActivatedIndex];
	ActiveEntry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::InProgress;
	ActiveEntry.SourceTrainingSessionId = TrainingSessionId;
	ActiveEntry.StartActionSourceLabel = !StartActionSourceLabel.IsEmpty()
		? StartActionSourceLabel
		: SourceLabel;
	ActiveEntry.ScheduledAtUtc = !ActiveEntry.ScheduledAtUtc.IsEmpty()
		? ActiveEntry.ScheduledAtUtc
		: ResolvedStartedAtUtc;
	ActiveEntry.DeferredUntilUtc.Reset();
	ActiveEntry.StartedAtUtc = ResolvedStartedAtUtc;
	ActiveEntry.bCanStartImmediately = false;
	UpdatedQueueState.LastUpdatedAtUtc = ResolvedStartedAtUtc;
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(UpdatedQueueState);
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRepositoryLibrary::StartCoachSessionQueueEntryById(
	const FHyperTwistTrainingCoachSessionQueueState& QueueState,
	const FString& EntryId,
	const FString& TrainingSessionId,
	const FString& StartedAtUtc
)
{
	FHyperTwistTrainingCoachSessionQueueState UpdatedQueueState =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
	if (!UpdatedQueueState.IsStructurallyValid() || EntryId.IsEmpty())
	{
		return UpdatedQueueState;
	}

	const FString ResolvedStartedAtUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(StartedAtUtc);
	const int32 ActivatedIndex = UpdatedQueueState.Entries.IndexOfByPredicate(
		[&EntryId](const FHyperTwistTrainingCoachSessionQueueStateEntry& Candidate)
		{
			return Candidate.EntryId == EntryId
				&& Candidate.EntryState != EHyperTwistTrainingCoachSessionQueueEntryState::Deferred
				&& !HyperTwistTrainingRepositoryLibraryInternal::IsTerminalCoachQueueEntryState(Candidate.EntryState);
		}
	);
	if (ActivatedIndex == INDEX_NONE)
	{
		return UpdatedQueueState;
	}

	for (FHyperTwistTrainingCoachSessionQueueStateEntry& Entry : UpdatedQueueState.Entries)
	{
		if (Entry.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress)
		{
			Entry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Pending;
			Entry.SourceTrainingSessionId.Reset();
			Entry.StartedAtUtc.Reset();
			Entry.bCanStartImmediately = false;
		}
	}

	FHyperTwistTrainingCoachSessionQueueStateEntry& ActiveEntry =
		UpdatedQueueState.Entries[ActivatedIndex];
	ActiveEntry.EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::InProgress;
	ActiveEntry.SourceTrainingSessionId = TrainingSessionId;
	ActiveEntry.ScheduledAtUtc = !ActiveEntry.ScheduledAtUtc.IsEmpty()
		? ActiveEntry.ScheduledAtUtc
		: ResolvedStartedAtUtc;
	ActiveEntry.DeferredUntilUtc.Reset();
	ActiveEntry.StartedAtUtc = ResolvedStartedAtUtc;
	ActiveEntry.bCanStartImmediately = false;
	UpdatedQueueState.LastUpdatedAtUtc = ResolvedStartedAtUtc;
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(UpdatedQueueState);
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRepositoryLibrary::FinalizeCoachSessionQueueEntry(
	const FHyperTwistTrainingCoachSessionQueueState& QueueState,
	const FString& TrainingSessionId,
	const FString& CompletedAtUtc,
	bool bAbortEntry
)
{
	FHyperTwistTrainingCoachSessionQueueState UpdatedQueueState =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
	if (!UpdatedQueueState.IsStructurallyValid())
	{
		return UpdatedQueueState;
	}

	const FString ResolvedCompletedAtUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
			CompletedAtUtc.IsEmpty() ? UpdatedQueueState.ReferenceUtc : CompletedAtUtc
		);
	FHyperTwistTrainingCoachSessionQueueStateEntry* ActiveEntry =
		UpdatedQueueState.Entries.FindByPredicate(
			[&TrainingSessionId, &UpdatedQueueState](const FHyperTwistTrainingCoachSessionQueueStateEntry& Candidate)
			{
				if (!TrainingSessionId.IsEmpty() && Candidate.SourceTrainingSessionId == TrainingSessionId)
				{
					return true;
				}

				return Candidate.EntryId == UpdatedQueueState.ActiveEntryId
					&& Candidate.EntryState == EHyperTwistTrainingCoachSessionQueueEntryState::InProgress;
			}
		);
	if (ActiveEntry == nullptr)
	{
		return UpdatedQueueState;
	}

	ActiveEntry->EntryState = bAbortEntry
		? EHyperTwistTrainingCoachSessionQueueEntryState::Skipped
		: EHyperTwistTrainingCoachSessionQueueEntryState::Completed;
	ActiveEntry->CompletedAtUtc = ResolvedCompletedAtUtc;
	ActiveEntry->bCanStartImmediately = false;
	UpdatedQueueState.ActiveEntryId.Reset();
	UpdatedQueueState.ActiveTrainingSessionId.Reset();
	UpdatedQueueState.LastUpdatedAtUtc = ResolvedCompletedAtUtc;
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(UpdatedQueueState);
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRepositoryLibrary::DeferCoachSessionQueueEntry(
	const FHyperTwistTrainingCoachSessionQueueState& QueueState,
	const FString& EntryId,
	const FString& DeferredUntilUtc,
	const FString& DeferralReasonLabel,
	bool bManualReschedule,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachSessionQueueState UpdatedQueueState =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
	if (!UpdatedQueueState.IsStructurallyValid() || EntryId.IsEmpty() || DeferredUntilUtc.IsEmpty())
	{
		return UpdatedQueueState;
	}

	const FString ResolvedReferenceUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
			ReferenceUtc.IsEmpty() ? UpdatedQueueState.ReferenceUtc : ReferenceUtc
		);
	FHyperTwistTrainingCoachSessionQueueStateEntry* EntryToDefer =
		UpdatedQueueState.Entries.FindByPredicate(
			[&EntryId](const FHyperTwistTrainingCoachSessionQueueStateEntry& Candidate)
			{
				return Candidate.EntryId == EntryId
					&& Candidate.EntryState != EHyperTwistTrainingCoachSessionQueueEntryState::InProgress
					&& !HyperTwistTrainingRepositoryLibraryInternal::IsTerminalCoachQueueEntryState(Candidate.EntryState);
			}
		);
	if (EntryToDefer == nullptr)
	{
		return UpdatedQueueState;
	}

	EntryToDefer->EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Deferred;
	EntryToDefer->DeferredUntilUtc = DeferredUntilUtc;
	EntryToDefer->DeferredAtUtc = ResolvedReferenceUtc;
	EntryToDefer->DeferralReasonLabel = !DeferralReasonLabel.IsEmpty()
		? DeferralReasonLabel
		: (bManualReschedule ? TEXT("manual-reschedule") : TEXT("deferred-window"));
	EntryToDefer->SourceTrainingSessionId.Reset();
	EntryToDefer->StartedAtUtc.Reset();
	EntryToDefer->CompletedAtUtc.Reset();
	EntryToDefer->bCanStartImmediately = false;
	EntryToDefer->RescheduleCount += 1;
	EntryToDefer->bWasManuallyRescheduled = EntryToDefer->bWasManuallyRescheduled || bManualReschedule;
	UpdatedQueueState.ActiveEntryId.Reset();
	UpdatedQueueState.ActiveTrainingSessionId.Reset();
	UpdatedQueueState.LastUpdatedAtUtc = ResolvedReferenceUtc;
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(UpdatedQueueState);
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRepositoryLibrary::PromoteCoachSessionQueueEntry(
	const FHyperTwistTrainingCoachSessionQueueState& QueueState,
	const FString& EntryId,
	const FString& StartActionSourceLabel,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachSessionQueueState UpdatedQueueState =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
	if (!UpdatedQueueState.IsStructurallyValid() || EntryId.IsEmpty())
	{
		return UpdatedQueueState;
	}

	const FString ResolvedReferenceUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
			ReferenceUtc.IsEmpty() ? UpdatedQueueState.ReferenceUtc : ReferenceUtc
		);
	FHyperTwistTrainingCoachSessionQueueStateEntry* EntryToPromote =
		UpdatedQueueState.Entries.FindByPredicate(
			[&EntryId](const FHyperTwistTrainingCoachSessionQueueStateEntry& Candidate)
			{
				return Candidate.EntryId == EntryId
					&& Candidate.EntryState != EHyperTwistTrainingCoachSessionQueueEntryState::InProgress
					&& !HyperTwistTrainingRepositoryLibraryInternal::IsTerminalCoachQueueEntryState(Candidate.EntryState);
			}
		);
	if (EntryToPromote == nullptr)
	{
		return UpdatedQueueState;
	}

	EntryToPromote->EntryState = EHyperTwistTrainingCoachSessionQueueEntryState::Ready;
	EntryToPromote->ScheduledAtUtc = ResolvedReferenceUtc;
	EntryToPromote->DeferredUntilUtc.Reset();
	EntryToPromote->bCanStartImmediately = true;
	EntryToPromote->SlotIndex = -1;
	if (!StartActionSourceLabel.IsEmpty())
	{
		EntryToPromote->StartActionSourceLabel = StartActionSourceLabel;
	}
	UpdatedQueueState.LastUpdatedAtUtc = ResolvedReferenceUtc;
	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(UpdatedQueueState);
}

TArray<FHyperTwistTrainingCoachSessionQueueState> UHyperTwistTrainingRepositoryLibrary::ListCoachSessionQueueStatesForUser(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId
)
{
	TArray<FHyperTwistTrainingCoachSessionQueueState> QueueStates;
	if (UserId.IsEmpty())
	{
		return QueueStates;
	}

	for (const FHyperTwistTrainingCoachSessionQueueState& QueueState : RepositoryState.StoredCoachSessionQueues)
	{
		if (QueueState.UserId == UserId && QueueState.IsStructurallyValid())
		{
			QueueStates.Add(QueueState);
		}
	}

	QueueStates.Sort([](
		const FHyperTwistTrainingCoachSessionQueueState& Left,
		const FHyperTwistTrainingCoachSessionQueueState& Right
	)
	{
		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.LastUpdatedAtUtc,
			Right.LastUpdatedAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare > 0;
		}

		return Left.QueueId < Right.QueueId;
	});
	return QueueStates;
}

TArray<FHyperTwistTrainingCoachSessionQueueHistoryEntry> UHyperTwistTrainingRepositoryLibrary::ListCoachSessionQueueHistoryEntries(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& QueueId
)
{
	TArray<FHyperTwistTrainingCoachSessionQueueHistoryEntry> HistoryEntries;
	if (UserId.IsEmpty() || QueueId.IsEmpty())
	{
		return HistoryEntries;
	}

	for (const FHyperTwistTrainingCoachSessionQueueHistoryEntry& HistoryEntry : RepositoryState.StoredCoachSessionQueueHistory)
	{
		if (HistoryEntry.UserId == UserId
			&& HistoryEntry.QueueId == QueueId
			&& HistoryEntry.IsStructurallyValid())
		{
			HistoryEntries.Add(HistoryEntry);
		}
	}

	HistoryEntries.Sort([](
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Left,
		const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Right
	)
	{
		const int32 UtcCompare = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			Left.EventAtUtc,
			Right.EventAtUtc
		);
		if (UtcCompare != 0)
		{
			return UtcCompare < 0;
		}

		return Left.HistoryEntryId < Right.HistoryEntryId;
	});
	return HistoryEntries;
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetCoachSessionQueueState(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& QueueId,
	FHyperTwistTrainingCoachSessionQueueState& OutQueueState
)
{
	OutQueueState = FHyperTwistTrainingCoachSessionQueueState();
	if (UserId.IsEmpty() || QueueId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingCoachSessionQueueState* MatchingQueueState =
		RepositoryState.StoredCoachSessionQueues.FindByPredicate(
			[&UserId, &QueueId](const FHyperTwistTrainingCoachSessionQueueState& Candidate)
			{
				return Candidate.UserId == UserId
					&& Candidate.QueueId == QueueId
					&& Candidate.IsStructurallyValid();
			}
		);
	if (MatchingQueueState == nullptr)
	{
		return false;
	}

	OutQueueState = *MatchingQueueState;
	return true;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertCoachSessionQueueState(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingCoachSessionQueueState& QueueState
)
{
	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	const FHyperTwistTrainingCoachSessionQueueState NormalizedQueueState =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachSessionQueueState(QueueState);
	if (!NormalizedQueueState.IsStructurallyValid())
	{
		return UpdatedRepositoryState;
	}

	const FHyperTwistTrainingCoachSessionQueueState* ExistingQueueState =
		UpdatedRepositoryState.StoredCoachSessionQueues.FindByPredicate(
			[&NormalizedQueueState](const FHyperTwistTrainingCoachSessionQueueState& Candidate)
			{
				return Candidate.UserId == NormalizedQueueState.UserId
					&& Candidate.QueueId == NormalizedQueueState.QueueId;
			}
		);

	for (const FHyperTwistTrainingCoachSessionQueueStateEntry& CurrentEntry : NormalizedQueueState.Entries)
	{
		const FHyperTwistTrainingCoachSessionQueueStateEntry* PreviousEntry = ExistingQueueState != nullptr
			? ExistingQueueState->Entries.FindByPredicate(
				[&CurrentEntry](const FHyperTwistTrainingCoachSessionQueueStateEntry& Candidate)
				{
					return Candidate.EntryId == CurrentEntry.EntryId;
				}
			)
			: nullptr;
		if (PreviousEntry != nullptr && PreviousEntry->WorkFingerprint != CurrentEntry.WorkFingerprint)
		{
			PreviousEntry = nullptr;
		}
		if (PreviousEntry != nullptr
			&& !HyperTwistTrainingRepositoryLibraryInternal::DidCoachSessionQueueEntryChange(
				*PreviousEntry,
				CurrentEntry
			))
		{
			continue;
		}

		const FHyperTwistTrainingCoachSessionQueueHistoryEntry HistoryEntry =
			HyperTwistTrainingRepositoryLibraryInternal::BuildCoachSessionQueueHistoryEntry(
				NormalizedQueueState,
				CurrentEntry,
				PreviousEntry
			);
		if (!HistoryEntry.IsStructurallyValid())
		{
			continue;
		}

		const bool bAlreadyExists =
			UpdatedRepositoryState.StoredCoachSessionQueueHistory.ContainsByPredicate(
				[&HistoryEntry](const FHyperTwistTrainingCoachSessionQueueHistoryEntry& Candidate)
				{
					return Candidate.HistoryEntryId == HistoryEntry.HistoryEntryId;
				}
			);
		if (!bAlreadyExists)
		{
			UpdatedRepositoryState.StoredCoachSessionQueueHistory.Add(HistoryEntry);
		}
	}

	FHyperTwistTrainingCoachSessionQueueState* MutableExistingQueueState =
		UpdatedRepositoryState.StoredCoachSessionQueues.FindByPredicate(
			[&NormalizedQueueState](const FHyperTwistTrainingCoachSessionQueueState& Candidate)
			{
				return Candidate.UserId == NormalizedQueueState.UserId
					&& Candidate.QueueId == NormalizedQueueState.QueueId;
			}
		);
	if (MutableExistingQueueState != nullptr)
	{
		*MutableExistingQueueState = NormalizedQueueState;
	}
	else
	{
		UpdatedRepositoryState.StoredCoachSessionQueues.Add(NormalizedQueueState);
	}

	return UpdatedRepositoryState;
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::RemoveCoachSessionQueueState(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& QueueId
)
{
	if (UserId.IsEmpty() || QueueId.IsEmpty())
	{
		return RepositoryState;
	}

	FHyperTwistTrainingRepositoryState UpdatedRepositoryState = RepositoryState;
	UpdatedRepositoryState.StoredCoachSessionQueues.RemoveAll(
		[&UserId, &QueueId](const FHyperTwistTrainingCoachSessionQueueState& Candidate)
		{
			return Candidate.UserId == UserId && Candidate.QueueId == QueueId;
		}
	);
	return UpdatedRepositoryState;
}

FHyperTwistTrainingCoachSessionQueueExecutionSummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachSessionQueueExecutionSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& QueueId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachSessionQueueExecutionSummary Summary;
	if (UserId.IsEmpty() || QueueId.IsEmpty())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.QueueId = QueueId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	FHyperTwistTrainingCoachSessionQueueState QueueState;
	if (TryGetCoachSessionQueueState(RepositoryState, UserId, QueueId, QueueState))
	{
		Summary.FocusDeckId = QueueState.FocusDeckId;
		Summary.FocusMethodSegmentId = QueueState.FocusMethodSegmentId;
		Summary.bHasOutstandingDeferredWork =
			QueueState.DeferredEntryCount > 0 || QueueState.PendingEntryCount > 0;
	}

	const TArray<FHyperTwistTrainingCoachSessionQueueHistoryEntry> HistoryEntries =
		ListCoachSessionQueueHistoryEntries(RepositoryState, UserId, QueueId);
	if (HistoryEntries.Num() == 0)
	{
		return Summary;
	}

	Summary.TotalHistoryEntryCount = HistoryEntries.Num();
	TSet<FString> UniqueEntryIds;
	TMap<FString, int32> DeferredCountsByEntryId;
	TMap<FString, int32> CompletedCountsByEntryId;
	TMap<FString, int32> DeferralReasonCounts;

	for (const FHyperTwistTrainingCoachSessionQueueHistoryEntry& HistoryEntry : HistoryEntries)
	{
		if (!HistoryEntry.IsStructurallyValid())
		{
			continue;
		}

		UniqueEntryIds.Add(HistoryEntry.EntryId);
		if (Summary.FocusDeckId.IsEmpty())
		{
			Summary.FocusDeckId = HistoryEntry.FocusDeckId;
		}
		if (Summary.FocusMethodSegmentId.IsEmpty())
		{
			Summary.FocusMethodSegmentId = HistoryEntry.FocusMethodSegmentId;
		}

		if (HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
			HistoryEntry.EventAtUtc,
			Summary.ReferenceUtc
		) > 0)
		{
			continue;
		}

		const EHyperTwistTrainingCoachGuidanceLane HistoryEntryLane =
			HistoryEntry.bRequiresFollowUp
				? EHyperTwistTrainingCoachGuidanceLane::FollowUp
				: HyperTwistTrainingRepositoryLibraryInternal::GuidanceLaneFromQueueSourceLabel(
					HistoryEntry.SourceLabel);

		switch (HistoryEntry.EventKind)
		{
		case EHyperTwistTrainingCoachSessionQueueEventKind::Queued:
			Summary.QueuedEventCount += 1;
			break;
		case EHyperTwistTrainingCoachSessionQueueEventKind::Ready:
			Summary.ReadyEventCount += 1;
			break;
		case EHyperTwistTrainingCoachSessionQueueEventKind::Started:
		{
			Summary.StartedEventCount += 1;
			if (HistoryEntryLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp)
			{
				Summary.StartedFollowUpEventCount += 1;
			}
			else if (HistoryEntryLane == EHyperTwistTrainingCoachGuidanceLane::Recommended)
			{
				Summary.StartedRecommendedEventCount += 1;
			}
			const EHyperTwistTrainingCoachHandoffKind DashboardHandoffKind =
				HyperTwistTrainingRepositoryLibraryInternal::DashboardHandoffKindFromSourceLabel(
					HistoryEntry.StartActionSourceLabel);
			const bool bDeferredOverflowDashboardOutcome =
				HyperTwistTrainingRepositoryLibraryInternal::IsDeferredOverflowDashboardOutcomeSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bDeferredFirstDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsDeferredFirstDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bMethodDrillDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bStrongMethodDrillRecoveryDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsStrongMethodDrillRecoveryDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bStrongMethodDrillFollowUpPacketDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsStrongMethodDrillFollowUpPacketDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bAlignedTightFollowUpPacketDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bAlignedBroadRecommendedPacketDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bStrongMethodDrillRecoveryPacketDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsStrongMethodDrillRecoveryPacketDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bNarrowMethodDrillRecoveryStructureDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsNarrowMethodDrillRecoveryStructureDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bTightMethodDrillRecoveryStructurePlanDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bWeakMethodDrillRecoveryDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsWeakMethodDrillRecoveryDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bWeakMethodDrillFollowUpPacketDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsWeakMethodDrillFollowUpPacketDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bWeakMethodDrillRecoveryPacketDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsWeakMethodDrillRecoveryPacketDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bBroadMethodDrillRecoveryStructureDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructureDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bBroadMethodDrillRecoveryStructurePlanDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bStrongRetainedMethodDrillRecoveryPostureDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsStrongRetainedMethodDrillRecoveryPostureDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			const bool bWeakRetainedMethodDrillRecoveryPostureDashboardHandoff =
				HyperTwistTrainingRepositoryLibraryInternal::IsWeakRetainedMethodDrillRecoveryPostureDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel);
			if (DashboardHandoffKind == EHyperTwistTrainingCoachHandoffKind::Queue)
			{
				Summary.StartedQueuedHandoffEventCount += 1;
				if (bDeferredOverflowDashboardOutcome)
				{
					Summary.StartedDeferredOverflowQueuedHandoffEventCount += 1;
				}
				if (bDeferredFirstDashboardHandoff)
				{
					Summary.StartedDeferredFirstQueuedHandoffEventCount += 1;
				}
				if (bMethodDrillDashboardHandoff)
				{
					Summary.StartedMethodDrillQueuedHandoffEventCount += 1;
				}
				if (bStrongMethodDrillFollowUpPacketDashboardHandoff)
				{
					Summary.StartedStrongMethodDrillFollowUpPacketQueuedHandoffEventCount += 1;
				}
				if (bWeakMethodDrillFollowUpPacketDashboardHandoff)
				{
					Summary.StartedWeakMethodDrillFollowUpPacketQueuedHandoffEventCount += 1;
				}
				if (bAlignedTightFollowUpPacketDashboardHandoff)
				{
					Summary.StartedAlignedTightFollowUpPacketQueuedHandoffEventCount += 1;
				}
				if (bAlignedBroadRecommendedPacketDashboardHandoff)
				{
					Summary.StartedAlignedBroadRecommendedPacketQueuedHandoffEventCount += 1;
				}
				if (bStrongMethodDrillRecoveryPacketDashboardHandoff)
				{
					Summary.StartedStrongMethodDrillRecoveryPacketQueuedHandoffEventCount += 1;
				}
				if (bNarrowMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.StartedNarrowMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel))
				{
					Summary.StartedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bWeakMethodDrillRecoveryPacketDashboardHandoff)
				{
					Summary.StartedWeakMethodDrillRecoveryPacketQueuedHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.StartedBroadMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel))
				{
					Summary.StartedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
			}
			else if (DashboardHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp)
			{
				Summary.StartedFollowUpHandoffEventCount += 1;
				if (bDeferredOverflowDashboardOutcome)
				{
					Summary.StartedDeferredOverflowFollowUpHandoffEventCount += 1;
				}
				if (bDeferredFirstDashboardHandoff)
				{
					Summary.StartedDeferredFirstFollowUpHandoffEventCount += 1;
				}
				if (bMethodDrillDashboardHandoff)
				{
					Summary.StartedMethodDrillFollowUpHandoffEventCount += 1;
				}
				if (bStrongMethodDrillFollowUpPacketDashboardHandoff)
				{
					Summary.StartedStrongMethodDrillFollowUpPacketFollowUpHandoffEventCount += 1;
				}
				if (bWeakMethodDrillFollowUpPacketDashboardHandoff)
				{
					Summary.StartedWeakMethodDrillFollowUpPacketFollowUpHandoffEventCount += 1;
				}
				if (bAlignedTightFollowUpPacketDashboardHandoff)
				{
					Summary.StartedAlignedTightFollowUpPacketFollowUpHandoffEventCount += 1;
				}
				if (bAlignedBroadRecommendedPacketDashboardHandoff)
				{
					Summary.StartedAlignedBroadRecommendedPacketFollowUpHandoffEventCount += 1;
				}
				if (bStrongMethodDrillRecoveryPacketDashboardHandoff)
				{
					Summary.StartedStrongMethodDrillRecoveryPacketFollowUpHandoffEventCount += 1;
				}
				if (bNarrowMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.StartedNarrowMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bWeakMethodDrillRecoveryPacketDashboardHandoff)
				{
					Summary.StartedWeakMethodDrillRecoveryPacketFollowUpHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.StartedBroadMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
			}
			else if (DashboardHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended)
			{
				Summary.StartedRecommendedHandoffEventCount += 1;
				if (bDeferredOverflowDashboardOutcome)
				{
					Summary.StartedDeferredOverflowRecommendedHandoffEventCount += 1;
				}
				if (bDeferredFirstDashboardHandoff)
				{
					Summary.StartedDeferredFirstRecommendedHandoffEventCount += 1;
				}
				if (bMethodDrillDashboardHandoff)
				{
					Summary.StartedMethodDrillRecommendedHandoffEventCount += 1;
				}
				if (bStrongMethodDrillFollowUpPacketDashboardHandoff)
				{
					Summary.StartedStrongMethodDrillFollowUpPacketRecommendedHandoffEventCount += 1;
				}
				if (bWeakMethodDrillFollowUpPacketDashboardHandoff)
				{
					Summary.StartedWeakMethodDrillFollowUpPacketRecommendedHandoffEventCount += 1;
				}
				if (bAlignedTightFollowUpPacketDashboardHandoff)
				{
					Summary.StartedAlignedTightFollowUpPacketRecommendedHandoffEventCount += 1;
				}
				if (bAlignedBroadRecommendedPacketDashboardHandoff)
				{
					Summary.StartedAlignedBroadRecommendedPacketRecommendedHandoffEventCount += 1;
				}
				if (bStrongMethodDrillRecoveryPacketDashboardHandoff)
				{
					Summary.StartedStrongMethodDrillRecoveryPacketRecommendedHandoffEventCount += 1;
				}
				if (bNarrowMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.StartedNarrowMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bWeakMethodDrillRecoveryPacketDashboardHandoff)
				{
					Summary.StartedWeakMethodDrillRecoveryPacketRecommendedHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.StartedBroadMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.StartedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
			}
			if (bStrongMethodDrillRecoveryDashboardHandoff)
			{
				Summary.StartedStrongMethodDrillRecoveryMemoryHandoffEventCount += 1;
			}
			if (bWeakMethodDrillRecoveryDashboardHandoff)
			{
				Summary.StartedWeakMethodDrillRecoveryMemoryHandoffEventCount += 1;
			}
			if (bStrongRetainedMethodDrillRecoveryPostureDashboardHandoff)
			{
				Summary.StartedStrongRetainedMethodDrillRecoveryPostureHandoffEventCount += 1;
			}
			if (bWeakRetainedMethodDrillRecoveryPostureDashboardHandoff)
			{
				Summary.StartedWeakRetainedMethodDrillRecoveryPostureHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary.StartedAcceptedAlignedTightFollowUpPacketTrustHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHandoffEventCount += 1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.StartedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary.StartedAcceptedAlignedBroadRecommendedPacketTrustHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHandoffEventCount += 1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.StartedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (Summary.LastStartedAtUtc.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
					HistoryEntry.EventAtUtc,
					Summary.LastStartedAtUtc
				) > 0)
			{
				Summary.LastStartedAtUtc = HistoryEntry.EventAtUtc;
			}
			break;
		}
		case EHyperTwistTrainingCoachSessionQueueEventKind::Deferred:
			Summary.DeferredEventCount += 1;
			DeferredCountsByEntryId.FindOrAdd(HistoryEntry.EntryId) += 1;
			if (!HistoryEntry.DeferralReasonLabel.IsEmpty())
			{
				DeferralReasonCounts.FindOrAdd(HistoryEntry.DeferralReasonLabel) += 1;
			}
			if (Summary.LastDeferredAtUtc.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
					HistoryEntry.EventAtUtc,
					Summary.LastDeferredAtUtc
				) > 0)
			{
				Summary.LastDeferredAtUtc = HistoryEntry.EventAtUtc;
			}
			break;
		case EHyperTwistTrainingCoachSessionQueueEventKind::Promoted:
			Summary.PromotedEventCount += 1;
			if (HistoryEntryLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp)
			{
				Summary.PromotedFollowUpEventCount += 1;
			}
			else if (HistoryEntryLane == EHyperTwistTrainingCoachGuidanceLane::Recommended)
			{
				Summary.PromotedRecommendedEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsNarrowMethodDrillRecoveryStructureDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedNarrowMethodDrillRecoveryStructureHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructureDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedBroadMethodDrillRecoveryStructureHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary.PromotedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
			}
			break;
		case EHyperTwistTrainingCoachSessionQueueEventKind::Completed:
			Summary.CompletedEventCount += 1;
			if (HistoryEntryLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp)
			{
				Summary.CompletedFollowUpEventCount += 1;
			}
			else if (HistoryEntryLane == EHyperTwistTrainingCoachGuidanceLane::Recommended)
			{
				Summary.CompletedRecommendedEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsMethodDrillDashboardHandoffSource(
				HistoryEntry.StartActionSourceLabel))
			{
				const bool bStrongMethodDrillRecoveryDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsStrongMethodDrillRecoveryDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bNarrowMethodDrillRecoveryStructureDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsNarrowMethodDrillRecoveryStructureDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bTightMethodDrillRecoveryStructurePlanDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bWeakMethodDrillRecoveryDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsWeakMethodDrillRecoveryDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bBroadMethodDrillRecoveryStructureDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructureDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bBroadMethodDrillRecoveryStructurePlanDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bStrongRetainedMethodDrillRecoveryPostureDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsStrongRetainedMethodDrillRecoveryPostureDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const bool bWeakRetainedMethodDrillRecoveryPostureDashboardHandoff =
					HyperTwistTrainingRepositoryLibraryInternal::IsWeakRetainedMethodDrillRecoveryPostureDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel);
				const EHyperTwistTrainingCoachHandoffKind CompletedHandoffKind =
					HyperTwistTrainingRepositoryLibraryInternal::DashboardHandoffKindFromSourceLabel(
						HistoryEntry.StartActionSourceLabel);
				if (CompletedHandoffKind == EHyperTwistTrainingCoachHandoffKind::Queue)
				{
					Summary.CompletedMethodDrillQueuedHandoffEventCount += 1;
				}
				else if (CompletedHandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp)
				{
					Summary.CompletedMethodDrillFollowUpHandoffEventCount += 1;
				}
				else if (CompletedHandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended)
				{
					Summary.CompletedMethodDrillRecommendedHandoffEventCount += 1;
				}
				if (bStrongMethodDrillRecoveryDashboardHandoff)
				{
					Summary.CompletedStrongMethodDrillRecoveryMemoryHandoffEventCount += 1;
				}
				if (bNarrowMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.CompletedNarrowMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.CompletedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.CompletedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.CompletedReliableTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel))
				{
					Summary.CompletedReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bWeakMethodDrillRecoveryDashboardHandoff)
				{
					Summary.CompletedWeakMethodDrillRecoveryMemoryHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructureDashboardHandoff)
				{
					Summary.CompletedBroadMethodDrillRecoveryStructureHandoffEventCount += 1;
				}
				if (bBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.CompletedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.CompletedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bReliableTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoff)
				{
					Summary.CompletedReliableTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanDashboardHandoffSource(
						HistoryEntry.StartActionSourceLabel))
				{
					Summary.CompletedReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanHandoffEventCount += 1;
				}
				if (bStrongRetainedMethodDrillRecoveryPostureDashboardHandoff)
				{
					Summary.CompletedStrongRetainedMethodDrillRecoveryPostureHandoffEventCount += 1;
				}
				if (bWeakRetainedMethodDrillRecoveryPostureDashboardHandoff)
				{
					Summary.CompletedWeakRetainedMethodDrillRecoveryPostureHandoffEventCount += 1;
				}
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary.CompletedAcceptedAlignedTightFollowUpPacketTrustHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHandoffEventCount += 1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary.CompletedAcceptedAlignedBroadRecommendedPacketTrustHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHandoffEventCount += 1;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
					HistoryEntry.StartActionSourceLabel))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHandoffEventCount += 1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			if (HistoryEntry.StartActionSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary
					.CompletedAcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHandoffEventCount +=
					1;
			}
			CompletedCountsByEntryId.FindOrAdd(HistoryEntry.EntryId) += 1;
			if (Summary.LastCompletedAtUtc.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
					HistoryEntry.EventAtUtc,
					Summary.LastCompletedAtUtc
				) > 0)
			{
				Summary.LastCompletedAtUtc = HistoryEntry.EventAtUtc;
			}
			break;
		case EHyperTwistTrainingCoachSessionQueueEventKind::Skipped:
			Summary.SkippedEventCount += 1;
			break;
		case EHyperTwistTrainingCoachSessionQueueEventKind::Expired:
			Summary.ExpiredEventCount += 1;
			break;
		default:
			break;
		}

		if (HistoryEntry.bWasManualReschedule)
		{
			Summary.ManualRescheduleEventCount += 1;
		}
		if (HistoryEntry.bRequiresArchiveRetentionTuning)
		{
			Summary.ArchiveAwareEventCount += 1;
		}
		if (HistoryEntry.bRequiresFollowUp
			&& HistoryEntry.EventKind == EHyperTwistTrainingCoachSessionQueueEventKind::Deferred)
		{
			Summary.BlockedFollowUpEventCount += 1;
		}
	}

	Summary.UniqueEntryCount = UniqueEntryIds.Num();

	int32 DominantDeferredCount = 0;
	for (const TPair<FString, int32>& Pair : DeferredCountsByEntryId)
	{
		if (Pair.Value > DominantDeferredCount
			|| (Pair.Value == DominantDeferredCount
				&& (Summary.MostDeferredEntryId.IsEmpty() || Pair.Key < Summary.MostDeferredEntryId)))
		{
			DominantDeferredCount = Pair.Value;
			Summary.MostDeferredEntryId = Pair.Key;
		}
	}

	int32 DominantCompletedCount = 0;
	for (const TPair<FString, int32>& Pair : CompletedCountsByEntryId)
	{
		if (Pair.Value > DominantCompletedCount
			|| (Pair.Value == DominantCompletedCount
				&& (Summary.MostCompletedEntryId.IsEmpty() || Pair.Key < Summary.MostCompletedEntryId)))
		{
			DominantCompletedCount = Pair.Value;
			Summary.MostCompletedEntryId = Pair.Key;
		}
	}

	int32 DominantReasonCount = 0;
	for (const TPair<FString, int32>& Pair : DeferralReasonCounts)
	{
		if (Pair.Value > DominantReasonCount
			|| (Pair.Value == DominantReasonCount
				&& (Summary.DominantDeferralReasonLabel.IsEmpty() || Pair.Key < Summary.DominantDeferralReasonLabel)))
		{
			DominantReasonCount = Pair.Value;
			Summary.DominantDeferralReasonLabel = Pair.Key;
		}
	}

	const int32 TerminalEventCount =
		Summary.CompletedEventCount + Summary.SkippedEventCount + Summary.ExpiredEventCount;
	Summary.bHasCompletionGap = Summary.StartedEventCount > TerminalEventCount;
	Summary.bHasArchiveAwareFriction = Summary.ArchiveAwareEventCount > 0;
	Summary.bHasBlockedFollowUpFriction = Summary.BlockedFollowUpEventCount > 0;
	Summary.bHasRepeatManualRescheduleFriction = Summary.ManualRescheduleEventCount >= 2;
	Summary.ExecutionPressureScore = FMath::Clamp(
		static_cast<float>(Summary.DeferredEventCount) * 7.0f
			+ static_cast<float>(Summary.ManualRescheduleEventCount) * 10.0f
			+ static_cast<float>(Summary.ArchiveAwareEventCount) * 12.0f
			+ static_cast<float>(Summary.BlockedFollowUpEventCount) * 12.0f
			+ (Summary.bHasCompletionGap ? 10.0f : 0.0f),
		0.0f,
		100.0f
	);

	return Summary;
}

FHyperTwistTrainingCoachActionPlanSummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachActionPlanSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachActionPlanSummary Summary;
	if (UserId.IsEmpty())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingCoachActionPlan> ActionPlans = ListCoachActionPlansForUser(
		RepositoryState,
		UserId
	);
	if (ActionPlans.Num() == 0)
	{
		return Summary;
	}

	Summary.TotalPlanCount = ActionPlans.Num();
	int32 SuggestedModeCounts[5] = {0, 0, 0, 0, 0};
	int32 HandoffKindCounts[4] = {0, 0, 0, 0};
	TMap<FString, int32> FocusLaneCounts;
	TMap<FString, int32> ActionLabelCounts;
	TMap<FString, int32> HandoffSourceCounts;
	int32 CompletedPlanDurationAccumulator = 0;
	int32 CompletedPlanDurationCount = 0;
	float PriorityScoreAccumulator = 0.0f;
	FString LatestOpenPlanUtc;
	FString LatestCompletedUtc;

	for (const FHyperTwistTrainingCoachActionPlan& ActionPlan : ActionPlans)
	{
		PriorityScoreAccumulator += ActionPlan.PriorityScore;
		Summary.TotalEntryCount += ActionPlan.Entries.Num();
		FocusLaneCounts.FindOrAdd(ActionPlan.FocusLaneLabel) += 1;
		ActionLabelCounts.FindOrAdd(ActionPlan.PrimaryActionLabel) += 1;

		const int32 SuggestedModeIndex = static_cast<int32>(ActionPlan.SuggestedMode);
		if (SuggestedModeIndex >= 0 && SuggestedModeIndex < UE_ARRAY_COUNT(SuggestedModeCounts))
		{
			SuggestedModeCounts[SuggestedModeIndex] += 1;
		}
		const int32 HandoffKindIndex = static_cast<int32>(ActionPlan.PreferredCoachHandoffKind);
		if (HandoffKindIndex >= 0 && HandoffKindIndex < UE_ARRAY_COUNT(HandoffKindCounts))
		{
			HandoffKindCounts[HandoffKindIndex] += 1;
		}
		if (!ActionPlan.PreferredCoachHandoffSourceLabel.IsEmpty())
		{
			HandoffSourceCounts.FindOrAdd(ActionPlan.PreferredCoachHandoffSourceLabel) += 1;
		}

		int32 LocalCompletedEntries = 0;
		for (const FHyperTwistTrainingCoachActionPlanEntry& Entry : ActionPlan.Entries)
		{
			if (Entry.bCompleted)
			{
				LocalCompletedEntries += 1;
			}
			if (Entry.bPreferRecognitionReplayReview)
			{
				Summary.bHasRecognitionBiasedPlans = true;
			}
		}

		Summary.CompletedEntryCount += LocalCompletedEntries;
		Summary.OpenEntryCount += ActionPlan.Entries.Num() - LocalCompletedEntries;
		Summary.bHasRecognitionBiasedPlans = Summary.bHasRecognitionBiasedPlans || ActionPlan.bPreferRecognitionReplayReview;

		switch (ActionPlan.PlanState)
		{
		case EHyperTwistTrainingCoachActionPlanState::Draft:
			Summary.DraftPlanCount += 1;
			break;
		case EHyperTwistTrainingCoachActionPlanState::Active:
			Summary.ActivePlanCount += 1;
			break;
		case EHyperTwistTrainingCoachActionPlanState::Completed:
			Summary.CompletedPlanCount += 1;
			break;
		case EHyperTwistTrainingCoachActionPlanState::Aborted:
			Summary.AbortedPlanCount += 1;
			break;
		default:
			break;
		}

		if (ActionPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Active
			|| ActionPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Draft)
		{
			const FString SortUtc = !ActionPlan.StartedAtUtc.IsEmpty()
				? ActionPlan.StartedAtUtc
				: ActionPlan.CreatedAtUtc;
			if (Summary.CurrentPlanId.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, LatestOpenPlanUtc) > 0)
			{
				Summary.CurrentPlanId = ActionPlan.PlanId;
				Summary.FocusDeckId = ActionPlan.FocusDeckId;
				Summary.FocusMethodSegmentId = ActionPlan.FocusMethodSegmentId;
				LatestOpenPlanUtc = SortUtc;
			}
		}

		if (ActionPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Completed
			&& !ActionPlan.CompletedAtUtc.IsEmpty())
		{
			const int32 DurationMs = HyperTwistTrainingRepositoryLibraryInternal::ComputeElapsedMilliseconds(
				ActionPlan.CreatedAtUtc,
				ActionPlan.CompletedAtUtc
			);
			if (DurationMs > 0)
			{
				CompletedPlanDurationAccumulator += DurationMs;
				CompletedPlanDurationCount += 1;
				if (Summary.BestCompletedPlanDurationMs == 0 || DurationMs < Summary.BestCompletedPlanDurationMs)
				{
					Summary.BestCompletedPlanDurationMs = DurationMs;
				}
			}

			if (Summary.LastCompletedPlanId.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(ActionPlan.CompletedAtUtc, LatestCompletedUtc) > 0)
			{
				Summary.LastCompletedPlanId = ActionPlan.PlanId;
				LatestCompletedUtc = ActionPlan.CompletedAtUtc;
				if (Summary.CurrentPlanId.IsEmpty())
				{
					Summary.FocusDeckId = ActionPlan.FocusDeckId;
					Summary.FocusMethodSegmentId = ActionPlan.FocusMethodSegmentId;
				}
			}
		}

		if (ActionPlan.bNeedsCoachReview
			|| ActionPlan.bNeedsCadenceRecovery
			|| ActionPlan.bNeedsVarietyRotation
			|| ActionPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Aborted)
		{
			Summary.bNeedsCoachIntervention = true;
		}
	}

	Summary.AveragePriorityScore = PriorityScoreAccumulator / static_cast<float>(Summary.TotalPlanCount);
	if (CompletedPlanDurationCount > 0)
	{
		Summary.AverageCompletedPlanDurationMs =
			CompletedPlanDurationAccumulator / CompletedPlanDurationCount;
	}

	int32 BestModeCount = 0;
	for (int32 Index = 0; Index < UE_ARRAY_COUNT(SuggestedModeCounts); ++Index)
	{
		if (SuggestedModeCounts[Index] > BestModeCount)
		{
			BestModeCount = SuggestedModeCounts[Index];
			Summary.DominantSuggestedMode = static_cast<EHyperTwistTrainingDeliveryMode>(Index);
		}
	}

	int32 BestHandoffKindCount = 0;
	for (int32 Index = 0; Index < UE_ARRAY_COUNT(HandoffKindCounts); ++Index)
	{
		if (HandoffKindCounts[Index] > BestHandoffKindCount)
		{
			BestHandoffKindCount = HandoffKindCounts[Index];
			Summary.DominantPreferredCoachHandoffKind =
				static_cast<EHyperTwistTrainingCoachHandoffKind>(Index);
		}
	}

	int32 BestFocusLaneCount = 0;
	for (const TPair<FString, int32>& Pair : FocusLaneCounts)
	{
		if (Pair.Value > BestFocusLaneCount)
		{
			BestFocusLaneCount = Pair.Value;
			Summary.DominantFocusLaneLabel = Pair.Key;
		}
	}

	int32 BestActionLabelCount = 0;
	for (const TPair<FString, int32>& Pair : ActionLabelCounts)
	{
		if (Pair.Value > BestActionLabelCount)
		{
			BestActionLabelCount = Pair.Value;
			Summary.DominantActionLabel = Pair.Key;
		}
	}

	int32 BestHandoffSourceCount = 0;
	for (const TPair<FString, int32>& Pair : HandoffSourceCounts)
	{
		if (Pair.Value > BestHandoffSourceCount)
		{
			BestHandoffSourceCount = Pair.Value;
			Summary.DominantPreferredCoachHandoffSourceLabel = Pair.Key;
		}
	}

	Summary.ActionPressureScore =
		static_cast<float>(Summary.ActivePlanCount * 3)
		+ static_cast<float>(Summary.DraftPlanCount * 2)
		+ static_cast<float>(Summary.AbortedPlanCount * 2)
		+ (static_cast<float>(Summary.OpenEntryCount) * 0.5f)
		+ (Summary.bNeedsCoachIntervention ? 5.0f : 0.0f);

	return Summary;
}

FHyperTwistTrainingCoachActionPlanOutcomeSummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachActionPlanOutcomeSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingCoachActionPlan& ActionPlan,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachActionPlanOutcomeSummary Summary;
	const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(ActionPlan);
	if (!NormalizedPlan.IsStructurallyValid())
	{
		return Summary;
	}

	Summary.UserId = NormalizedPlan.UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
		!ReferenceUtc.IsEmpty() ? ReferenceUtc : NormalizedPlan.ReferenceUtc
	);
	Summary.PlanId = NormalizedPlan.PlanId;
	Summary.SourceSessionId = NormalizedPlan.SourceSessionId;
	Summary.FocusDeckId = NormalizedPlan.FocusDeckId;
	Summary.FocusMethodSegmentId = NormalizedPlan.FocusMethodSegmentId;
	Summary.PrimaryActionLabel = NormalizedPlan.PrimaryActionLabel;
	Summary.PlanState = NormalizedPlan.PlanState;
	Summary.SuggestedMode = NormalizedPlan.SuggestedMode;
	Summary.PreferredCoachHandoffKind = NormalizedPlan.PreferredCoachHandoffKind;
	Summary.PreferredCoachHandoffSourceLabel = NormalizedPlan.PreferredCoachHandoffSourceLabel;
	Summary.RequestedLaunchCaseCount = NormalizedPlan.RequestedLaunchCaseCount;
	Summary.PlannedLaunchCaseCount = NormalizedPlan.PlannedLaunchCaseCount;
	Summary.bBroadenedLaunchBudget = NormalizedPlan.bBroadenedLaunchBudget;
	Summary.bTightenedLaunchBudget = NormalizedPlan.bTightenedLaunchBudget;
	Summary.LaunchBudgetReasonLine = NormalizedPlan.LaunchBudgetReasonLine;
	Summary.DeferredLaunchCaseIds = NormalizedPlan.DeferredLaunchCaseIds;

	TSet<FString> FocusCaseIds;
	for (const FString& FocusCaseId : NormalizedPlan.FocusCaseIds)
	{
		if (!FocusCaseId.IsEmpty())
		{
			FocusCaseIds.Add(FocusCaseId);
		}
	}

	TSet<FString> CompletedCaseIds;
	for (const FHyperTwistTrainingCoachActionPlanEntry& Entry : NormalizedPlan.Entries)
	{
		if (!Entry.CaseId.IsEmpty() && FocusCaseIds.Num() == 0)
		{
			FocusCaseIds.Add(Entry.CaseId);
		}

		if (Entry.bCompleted && !Entry.CaseId.IsEmpty())
		{
			CompletedCaseIds.Add(Entry.CaseId);
		}
	}

	Summary.FocusCaseCount = FocusCaseIds.Num();

	FHyperTwistTrainingRunRecord RunRecord;
	if (!NormalizedPlan.SourceSessionId.IsEmpty()
		&& TryGetRunRecord(RepositoryState, NormalizedPlan.SourceSessionId, RunRecord))
	{
		TSet<FString> TouchedCaseIds;
		int32 TotalTimeAccumulator = 0;
		int32 TotalTimeSampleCount = 0;
		int32 RecognitionTimeAccumulator = 0;
		int32 RecognitionTimeSampleCount = 0;

		for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptHistoryEntry : RunRecord.AttemptHistory)
		{
			if (FocusCaseIds.Num() > 0 && !FocusCaseIds.Contains(AttemptHistoryEntry.CaseId))
			{
				continue;
			}

			Summary.AttemptCount += 1;
			TouchedCaseIds.Add(AttemptHistoryEntry.CaseId);

			if (!AttemptHistoryEntry.ReplayId.IsEmpty())
			{
				Summary.ReplayBackedAttemptCount += 1;
			}

			if (AttemptHistoryEntry.DeliveryMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted
				|| AttemptHistoryEntry.RecognitionTimeMs > 0)
			{
				Summary.RecognitionAttemptCount += 1;
			}

			if (AttemptHistoryEntry.TotalTimeMs > 0)
			{
				TotalTimeAccumulator += AttemptHistoryEntry.TotalTimeMs;
				TotalTimeSampleCount += 1;
				if (Summary.BestTotalTimeMs == 0 || AttemptHistoryEntry.TotalTimeMs < Summary.BestTotalTimeMs)
				{
					Summary.BestTotalTimeMs = AttemptHistoryEntry.TotalTimeMs;
				}
			}

			if (AttemptHistoryEntry.RecognitionTimeMs > 0)
			{
				RecognitionTimeAccumulator += AttemptHistoryEntry.RecognitionTimeMs;
				RecognitionTimeSampleCount += 1;
			}

			switch (AttemptHistoryEntry.Result)
			{
			case EHyperTwistTrainingAttemptResult::Success:
				Summary.SuccessCount += 1;
				if (!AttemptHistoryEntry.CaseId.IsEmpty())
				{
					CompletedCaseIds.Add(AttemptHistoryEntry.CaseId);
				}
				break;

			case EHyperTwistTrainingAttemptResult::Failure:
				Summary.FailureCount += 1;
				break;

			case EHyperTwistTrainingAttemptResult::Timeout:
				Summary.TimeoutCount += 1;
				break;

			case EHyperTwistTrainingAttemptResult::DNF:
				Summary.DNFCount += 1;
				break;

			case EHyperTwistTrainingAttemptResult::Aborted:
				Summary.AbortedCount += 1;
				break;

			default:
				break;
			}
		}

		Summary.TouchedFocusCaseCount = TouchedCaseIds.Num();
		if (TotalTimeSampleCount > 0)
		{
			Summary.AverageTotalTimeMs = TotalTimeAccumulator / TotalTimeSampleCount;
		}
		if (RecognitionTimeSampleCount > 0)
		{
			Summary.AverageRecognitionTimeMs = RecognitionTimeAccumulator / RecognitionTimeSampleCount;
		}
	}

	Summary.CompletedFocusCaseCount = CompletedCaseIds.Num();
	Summary.UntouchedFocusCaseCount = FMath::Max(0, Summary.FocusCaseCount - Summary.TouchedFocusCaseCount);
	for (const FString& FocusCaseId : NormalizedPlan.FocusCaseIds)
	{
		if (!FocusCaseId.IsEmpty() && !CompletedCaseIds.Contains(FocusCaseId))
		{
			Summary.FollowUpCaseIds.Add(FocusCaseId);
		}
	}
	if (Summary.FollowUpCaseIds.Num() == 0)
	{
		for (const FHyperTwistTrainingCoachActionPlanEntry& Entry : NormalizedPlan.Entries)
		{
			if (!Entry.CaseId.IsEmpty()
				&& !CompletedCaseIds.Contains(Entry.CaseId)
				&& !Summary.FollowUpCaseIds.Contains(Entry.CaseId))
			{
				Summary.FollowUpCaseIds.Add(Entry.CaseId);
			}
		}
	}
	if (Summary.FocusCaseCount > 0)
	{
		Summary.CompletionRate = static_cast<float>(Summary.CompletedFocusCaseCount)
			/ static_cast<float>(Summary.FocusCaseCount);
	}

	const FString PlanStartUtc = !NormalizedPlan.StartedAtUtc.IsEmpty()
		? NormalizedPlan.StartedAtUtc
		: NormalizedPlan.CreatedAtUtc;
	const FString PlanEndUtc = !NormalizedPlan.CompletedAtUtc.IsEmpty()
		? NormalizedPlan.CompletedAtUtc
		: Summary.ReferenceUtc;
	if (!PlanStartUtc.IsEmpty() && !PlanEndUtc.IsEmpty())
	{
		Summary.PlanDurationMs = HyperTwistTrainingRepositoryLibraryInternal::ComputeElapsedMilliseconds(
			PlanStartUtc,
			PlanEndUtc
		);
	}

	const bool bPlanTerminal =
		NormalizedPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Completed
		|| NormalizedPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Aborted;
	Summary.bMetPrimaryGoal =
		bPlanTerminal
		&& NormalizedPlan.PlanState != EHyperTwistTrainingCoachActionPlanState::Aborted
		&& (Summary.FocusCaseCount == 0
			? Summary.SuccessCount > 0
			: Summary.CompletedFocusCaseCount >= Summary.FocusCaseCount);

	Summary.OutcomeScore =
		(Summary.CompletionRate * 100.0f)
		+ (static_cast<float>(Summary.SuccessCount) * 4.0f)
		- (static_cast<float>(Summary.FailureCount) * 2.0f)
		- (static_cast<float>(Summary.TimeoutCount) * 3.0f)
		- (static_cast<float>(Summary.DNFCount) * 4.0f)
		- (static_cast<float>(Summary.AbortedCount) * 5.0f)
		- (static_cast<float>(Summary.UntouchedFocusCaseCount) * 4.0f)
		+ (static_cast<float>(Summary.ReplayBackedAttemptCount) * 0.5f);

	Summary.bNeedsFollowUpPlan =
		Summary.FollowUpCaseIds.Num() > 0
		|| Summary.DeferredLaunchCaseIds.Num() > 0
		|| (
			bPlanTerminal
			&& (
			NormalizedPlan.PlanState == EHyperTwistTrainingCoachActionPlanState::Aborted
			|| !Summary.bMetPrimaryGoal
			|| Summary.FailureCount > 0
			|| Summary.TimeoutCount > 0
			|| Summary.DNFCount > 0
			|| (NormalizedPlan.bNeedsCoachReview && Summary.ReplayBackedAttemptCount == 0)
		));

	return Summary;
}

FHyperTwistTrainingCoachActionSequenceSummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachActionSequenceSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingCoachActionPlan& AnchorPlan,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachActionSequenceSummary Summary;
	const FHyperTwistTrainingCoachActionPlan NormalizedAnchorPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(AnchorPlan);
	if (!NormalizedAnchorPlan.IsStructurallyValid())
	{
		return Summary;
	}

	const FString RootPlanId = !NormalizedAnchorPlan.RootPlanId.IsEmpty()
		? NormalizedAnchorPlan.RootPlanId
		: NormalizedAnchorPlan.PlanId;
	Summary.UserId = NormalizedAnchorPlan.UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(
		!ReferenceUtc.IsEmpty() ? ReferenceUtc : NormalizedAnchorPlan.ReferenceUtc
	);
	Summary.RootPlanId = RootPlanId;

	const TArray<FHyperTwistTrainingCoachActionPlan> UserPlans = ListCoachActionPlansForUser(
		RepositoryState,
		NormalizedAnchorPlan.UserId
	);
	TArray<FHyperTwistTrainingCoachActionPlan> SequencePlans;
	for (const FHyperTwistTrainingCoachActionPlan& Plan : UserPlans)
	{
		const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(Plan);
		const FString CandidateRootPlanId = !NormalizedPlan.RootPlanId.IsEmpty()
			? NormalizedPlan.RootPlanId
			: NormalizedPlan.PlanId;
		if (CandidateRootPlanId == RootPlanId
			|| NormalizedPlan.PlanId == RootPlanId
			|| NormalizedPlan.ParentPlanId == RootPlanId)
		{
			SequencePlans.Add(NormalizedPlan);
		}
	}
	if (SequencePlans.Num() == 0)
	{
		SequencePlans.Add(NormalizedAnchorPlan);
	}
	const auto ResolvePlanSortUtc = [](const FHyperTwistTrainingCoachActionPlan& Plan) -> FString
	{
		return !Plan.CompletedAtUtc.IsEmpty()
			? Plan.CompletedAtUtc
			: (!Plan.StartedAtUtc.IsEmpty() ? Plan.StartedAtUtc : Plan.CreatedAtUtc);
	};
	SequencePlans.Sort(
		[&ResolvePlanSortUtc](const FHyperTwistTrainingCoachActionPlan& Left,
			const FHyperTwistTrainingCoachActionPlan& Right)
		{
			const FString LeftSortUtc = ResolvePlanSortUtc(Left);
			const FString RightSortUtc = ResolvePlanSortUtc(Right);
			const int32 CompareResult =
				HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(LeftSortUtc, RightSortUtc);
			if (CompareResult != 0)
			{
				return CompareResult < 0;
			}
			if (Left.FollowUpDepth != Right.FollowUpDepth)
			{
				return Left.FollowUpDepth < Right.FollowUpDepth;
			}

			return Left.PlanId < Right.PlanId;
		}
	);

	FString LatestSortUtc;
	TSet<FString> OutstandingFollowUpCases;
	float CompletionRateAccumulator = 0.0f;
	float OutcomeScoreAccumulator = 0.0f;
	bool bHasGenericFollowUpPressure = false;

	for (const FHyperTwistTrainingCoachActionPlan& Plan : SequencePlans)
	{
		Summary.PlanCount += 1;
		Summary.CarryForwardPlanCount += Plan.FollowUpDepth > 0 ? 1 : 0;
		Summary.MaxFollowUpDepth = FMath::Max(Summary.MaxFollowUpDepth, Plan.FollowUpDepth);

		switch (Plan.PlanState)
		{
		case EHyperTwistTrainingCoachActionPlanState::Active:
			Summary.ActivePlanCount += 1;
			Summary.bHasOpenPlan = true;
			break;
		case EHyperTwistTrainingCoachActionPlanState::Completed:
			Summary.CompletedPlanCount += 1;
			break;
		case EHyperTwistTrainingCoachActionPlanState::Aborted:
			Summary.AbortedPlanCount += 1;
			break;
		default:
			Summary.bHasOpenPlan = true;
			break;
		}

		const FHyperTwistTrainingCoachActionPlanOutcomeSummary OutcomeSummary =
			DeriveCoachActionPlanOutcomeSummary(RepositoryState, Plan, Summary.ReferenceUtc);
		Summary.TotalFocusCaseCount +=
			OutcomeSummary.FocusCaseCount + OutcomeSummary.DeferredLaunchCaseIds.Num();
		CompletionRateAccumulator += OutcomeSummary.CompletionRate;
		OutcomeScoreAccumulator += OutcomeSummary.OutcomeScore;
		TSet<FString> PlanFocusCaseIds;
		for (const FString& FocusCaseId : Plan.FocusCaseIds)
		{
			if (!FocusCaseId.IsEmpty())
			{
				PlanFocusCaseIds.Add(FocusCaseId);
			}
		}
		for (const FHyperTwistTrainingCoachActionPlanEntry& Entry : Plan.Entries)
		{
			if (!Entry.CaseId.IsEmpty())
			{
				PlanFocusCaseIds.Add(Entry.CaseId);
			}
		}
		TSet<FString> PlanOutstandingCaseIds;
		for (const FString& CaseId : OutcomeSummary.FollowUpCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				PlanOutstandingCaseIds.Add(CaseId);
				OutstandingFollowUpCases.Add(CaseId);
			}
		}
		for (const FString& CaseId : OutcomeSummary.DeferredLaunchCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				PlanOutstandingCaseIds.Add(CaseId);
				OutstandingFollowUpCases.Add(CaseId);
			}
		}
		for (const FString& FocusCaseId : PlanFocusCaseIds)
		{
			if (!PlanOutstandingCaseIds.Contains(FocusCaseId))
			{
				OutstandingFollowUpCases.Remove(FocusCaseId);
			}
		}
		bHasGenericFollowUpPressure =
			OutcomeSummary.bNeedsFollowUpPlan && PlanOutstandingCaseIds.Num() == 0;

		const FString SortUtc = ResolvePlanSortUtc(Plan);
		if (Summary.LatestPlanId.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, LatestSortUtc) > 0
			|| (HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, LatestSortUtc) == 0
				&& Plan.FollowUpDepth >= Summary.MaxFollowUpDepth))
		{
			Summary.LatestPlanId = Plan.PlanId;
			Summary.FocusDeckId = Plan.FocusDeckId;
			Summary.FocusMethodSegmentId = Plan.FocusMethodSegmentId;
			Summary.LatestOutcomeScore = OutcomeSummary.OutcomeScore;
			LatestSortUtc = SortUtc;
		}
	}

	if (Summary.PlanCount > 0)
	{
		Summary.AverageCompletionRate = CompletionRateAccumulator / static_cast<float>(Summary.PlanCount);
		Summary.AverageOutcomeScore = OutcomeScoreAccumulator / static_cast<float>(Summary.PlanCount);
	}
	Summary.UnresolvedFollowUpCaseCount = OutstandingFollowUpCases.Num();
	Summary.bNeedsMoreFollowUp =
		Summary.UnresolvedFollowUpCaseCount > 0 || bHasGenericFollowUpPressure || Summary.bHasOpenPlan;

	return Summary;
}

namespace HyperTwistTrainingRepositoryLibraryInternal
{
	FHyperTwistTrainingCoachActionClosureSummary DeriveCoachActionClosureSummaryWithCoachMemory(
		const FHyperTwistTrainingRepositoryState& RepositoryState,
		const FHyperTwistTrainingCoachActionPlan& AnchorPlan,
		const FString& ReferenceUtc,
		const FHyperTwistTrainingCoachMemorySnapshot& CoachMemorySnapshot
	)
	{
	FHyperTwistTrainingCoachActionClosureSummary Summary;
	const FHyperTwistTrainingCoachActionPlan NormalizedAnchorPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(AnchorPlan);
	if (!NormalizedAnchorPlan.IsStructurallyValid())
	{
		return Summary;
	}

	const FHyperTwistTrainingCoachActionSequenceSummary SequenceSummary =
		UHyperTwistTrainingRepositoryLibrary::DeriveCoachActionSequenceSummary(
			RepositoryState,
			NormalizedAnchorPlan,
			ReferenceUtc
		);
	if (!SequenceSummary.IsStructurallyValid())
	{
		return Summary;
	}

	Summary.UserId = SequenceSummary.UserId;
	Summary.ReferenceUtc = SequenceSummary.ReferenceUtc;
	Summary.RootPlanId = SequenceSummary.RootPlanId;
	Summary.LatestPlanId = SequenceSummary.LatestPlanId;
	Summary.FocusDeckId = SequenceSummary.FocusDeckId;
	Summary.FocusMethodSegmentId = SequenceSummary.FocusMethodSegmentId;

	TArray<FHyperTwistTrainingCoachActionPlan> SequencePlans;
	const TArray<FHyperTwistTrainingCoachActionPlan> UserPlans =
		UHyperTwistTrainingRepositoryLibrary::ListCoachActionPlansForUser(
		RepositoryState,
		NormalizedAnchorPlan.UserId
	);
	for (const FHyperTwistTrainingCoachActionPlan& Plan : UserPlans)
	{
		const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(Plan);
		const FString CandidateRootPlanId = !NormalizedPlan.RootPlanId.IsEmpty()
			? NormalizedPlan.RootPlanId
			: NormalizedPlan.PlanId;
		if (CandidateRootPlanId == SequenceSummary.RootPlanId
			|| NormalizedPlan.PlanId == SequenceSummary.RootPlanId
			|| NormalizedPlan.ParentPlanId == SequenceSummary.RootPlanId)
		{
			SequencePlans.Add(NormalizedPlan);
		}
	}
	if (SequencePlans.Num() == 0)
	{
		SequencePlans.Add(NormalizedAnchorPlan);
	}
	const auto ResolvePlanSortUtc = [](const FHyperTwistTrainingCoachActionPlan& Plan) -> FString
	{
		return !Plan.CompletedAtUtc.IsEmpty()
			? Plan.CompletedAtUtc
			: (!Plan.StartedAtUtc.IsEmpty() ? Plan.StartedAtUtc : Plan.CreatedAtUtc);
	};
	SequencePlans.Sort(
		[&ResolvePlanSortUtc](const FHyperTwistTrainingCoachActionPlan& Left,
			const FHyperTwistTrainingCoachActionPlan& Right)
		{
			const FString LeftSortUtc = ResolvePlanSortUtc(Left);
			const FString RightSortUtc = ResolvePlanSortUtc(Right);
			const int32 CompareResult =
				HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(LeftSortUtc, RightSortUtc);
			if (CompareResult != 0)
			{
				return CompareResult < 0;
			}
			if (Left.FollowUpDepth != Right.FollowUpDepth)
			{
				return Left.FollowUpDepth < Right.FollowUpDepth;
			}

			return Left.PlanId < Right.PlanId;
		}
	);

	TSet<FString> AllFocusCaseIds;
	TSet<FString> ResolvedCaseIds;
	TSet<FString> UnresolvedCaseIds;
	TMap<FString, int32> CaseAttemptCounts;
	TMap<FString, int32> CaseNonSuccessCounts;
	TMap<FString, int32> CaseSuccessCounts;
	bool bAnyRecognition = false;

	for (const FHyperTwistTrainingCoachActionPlan& Plan : SequencePlans)
	{
		const FHyperTwistTrainingCoachActionPlanOutcomeSummary OutcomeSummary =
			UHyperTwistTrainingRepositoryLibrary::DeriveCoachActionPlanOutcomeSummary(
				RepositoryState,
				Plan,
				SequenceSummary.ReferenceUtc
			);
		TSet<FString> PlanFocusCaseIds;
		for (const FString& FocusCaseId : Plan.FocusCaseIds)
		{
			if (!FocusCaseId.IsEmpty())
			{
				PlanFocusCaseIds.Add(FocusCaseId);
				AllFocusCaseIds.Add(FocusCaseId);
			}
		}
		for (const FHyperTwistTrainingCoachActionPlanEntry& Entry : Plan.Entries)
		{
			if (!Entry.CaseId.IsEmpty())
			{
				PlanFocusCaseIds.Add(Entry.CaseId);
				AllFocusCaseIds.Add(Entry.CaseId);
			}
		}

		TSet<FString> PlanOutstandingCaseIds;
		for (const FString& FollowUpCaseId : OutcomeSummary.FollowUpCaseIds)
		{
			if (!FollowUpCaseId.IsEmpty())
			{
				PlanOutstandingCaseIds.Add(FollowUpCaseId);
				UnresolvedCaseIds.Add(FollowUpCaseId);
				ResolvedCaseIds.Remove(FollowUpCaseId);
			}
		}
		for (const FString& DeferredCaseId : OutcomeSummary.DeferredLaunchCaseIds)
		{
			if (!DeferredCaseId.IsEmpty())
			{
				PlanOutstandingCaseIds.Add(DeferredCaseId);
				AllFocusCaseIds.Add(DeferredCaseId);
				UnresolvedCaseIds.Add(DeferredCaseId);
				ResolvedCaseIds.Remove(DeferredCaseId);
			}
		}

		for (const FString& FocusCaseId : PlanFocusCaseIds)
		{
			if (PlanOutstandingCaseIds.Contains(FocusCaseId))
			{
				UnresolvedCaseIds.Add(FocusCaseId);
				ResolvedCaseIds.Remove(FocusCaseId);
			}
			else
			{
				UnresolvedCaseIds.Remove(FocusCaseId);
				ResolvedCaseIds.Add(FocusCaseId);
			}
		}

		FHyperTwistTrainingRunRecord RunRecord;
		if (!Plan.SourceSessionId.IsEmpty()
			&& UHyperTwistTrainingRepositoryLibrary::TryGetRunRecord(
				RepositoryState,
				Plan.SourceSessionId,
				RunRecord
			))
		{
			for (const FHyperTwistTrainingAttemptHistoryEntry& AttemptHistoryEntry : RunRecord.AttemptHistory)
			{
				if (!AllFocusCaseIds.Contains(AttemptHistoryEntry.CaseId))
				{
					continue;
				}

				Summary.TotalAttemptCount += 1;
				CaseAttemptCounts.FindOrAdd(AttemptHistoryEntry.CaseId) += 1;
				if (AttemptHistoryEntry.DeliveryMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted
					|| AttemptHistoryEntry.RecognitionTimeMs > 0)
				{
					bAnyRecognition = true;
				}

				if (AttemptHistoryEntry.Result == EHyperTwistTrainingAttemptResult::Success)
				{
					CaseSuccessCounts.FindOrAdd(AttemptHistoryEntry.CaseId) += 1;
				}
				else
				{
					CaseNonSuccessCounts.FindOrAdd(AttemptHistoryEntry.CaseId) += 1;
				}
			}
		}
	}

	for (const FString& UnresolvedCaseId : UnresolvedCaseIds)
	{
		ResolvedCaseIds.Remove(UnresolvedCaseId);
	}

	TSet<FString> PersistentWeakCaseIds;
	for (const TPair<FString, int32>& Pair : CaseNonSuccessCounts)
	{
		const int32 SuccessCount = CaseSuccessCounts.FindRef(Pair.Key);
		if (Pair.Value >= 2
			|| (UnresolvedCaseIds.Contains(Pair.Key) && Pair.Value >= 1)
			|| (SuccessCount == 0 && CaseAttemptCounts.FindRef(Pair.Key) >= 2))
		{
			PersistentWeakCaseIds.Add(Pair.Key);
		}
	}

	Summary.ResolvedCaseIds = ResolvedCaseIds.Array();
	Summary.PersistentWeakCaseIds = PersistentWeakCaseIds.Array();
	Summary.UnresolvedCaseIds = UnresolvedCaseIds.Array();
	Summary.ResolvedCaseIds.Sort();
	Summary.PersistentWeakCaseIds.Sort();
	Summary.UnresolvedCaseIds.Sort();
	Summary.ResolvedCaseCount = Summary.ResolvedCaseIds.Num();
	Summary.PersistentWeakCaseCount = Summary.PersistentWeakCaseIds.Num();
	Summary.UnresolvedCaseCount = Summary.UnresolvedCaseIds.Num();
	Summary.RepeatedFailureCaseCount = Summary.PersistentWeakCaseCount;

	Summary.bSequenceClosed =
		!SequenceSummary.bHasOpenPlan
		&& !SequenceSummary.bNeedsMoreFollowUp
		&& Summary.UnresolvedCaseCount == 0
		&& SequenceSummary.CompletedPlanCount > 0
		&& SequenceSummary.AbortedPlanCount == 0;
	Summary.bNeedsEscalation =
		SequenceSummary.AbortedPlanCount > 0
		|| (SequenceSummary.MaxFollowUpDepth >= 2 && Summary.UnresolvedCaseCount > 0)
		|| Summary.PersistentWeakCaseCount >= 2
		|| SequenceSummary.AverageOutcomeScore < 30.0f;
	const bool bPrefersFollowUpLane =
		CoachMemorySnapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp
		|| CoachMemorySnapshot.FollowUpGuidanceContinueBias > CoachMemorySnapshot.RecommendedGuidanceContinueBias;
	const bool bPrefersRecommendedLane =
		CoachMemorySnapshot.PreferredGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended
		|| CoachMemorySnapshot.RecommendedGuidanceContinueBias > CoachMemorySnapshot.FollowUpGuidanceContinueBias;
	const bool bHasRawFollowUpPressure =
		Summary.UnresolvedCaseCount > 0 || Summary.PersistentWeakCaseCount > 0;
	Summary.bSpawnFollowUpFromSuppressionMemory =
		!bHasRawFollowUpPressure
		&& SequenceSummary.bNeedsMoreFollowUp
		&& SequenceSummary.CompletedPlanCount > 0
		&& !Summary.bNeedsEscalation
		&& bPrefersFollowUpLane
		&& CoachMemorySnapshot.SuppressedPrimaryQueuePressureCount
			>= CoachMemorySnapshot.SuppressedFollowUpQueuePressureCount;
	Summary.bSuppressedBorderlineFollowUpByRecoveryHistory =
		bHasRawFollowUpPressure
		&& Summary.PersistentWeakCaseCount == 0
		&& Summary.UnresolvedCaseCount <= 1
		&& !SequenceSummary.bNeedsMoreFollowUp
		&& !Summary.bNeedsEscalation
		&& bPrefersRecommendedLane
		&& CoachMemorySnapshot.SuppressedFollowUpQueuePressureCount
			>= CoachMemorySnapshot.SuppressedPrimaryQueuePressureCount + 2;
	Summary.bShouldSpawnFollowUp =
		!Summary.bSequenceClosed
		&& !SequenceSummary.bHasOpenPlan
		&& !Summary.bSuppressedBorderlineFollowUpByRecoveryHistory
		&& (bHasRawFollowUpPressure || Summary.bSpawnFollowUpFromSuppressionMemory);
	Summary.bShouldArchiveResolvedCases =
		Summary.ResolvedCaseCount > 0
		&& (Summary.bSequenceClosed || (!Summary.bShouldSpawnFollowUp && Summary.PersistentWeakCaseCount == 0));

	if (Summary.bSequenceClosed)
	{
		Summary.ClosureLabel = TEXT("sequence-closed");
		Summary.RecommendedNextMode = EHyperTwistTrainingDeliveryMode::Timer;
	}
	else if (Summary.bNeedsEscalation)
	{
		Summary.ClosureLabel = TEXT("needs-escalation");
		Summary.RecommendedNextMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
	}
	else if (Summary.bShouldSpawnFollowUp)
	{
		Summary.ClosureLabel = Summary.bSpawnFollowUpFromSuppressionMemory
			? TEXT("follow-up-memory-ready")
			: TEXT("follow-up-ready");
		Summary.RecommendedNextMode = bAnyRecognition
			? EHyperTwistTrainingDeliveryMode::RecognitionAssisted
			: EHyperTwistTrainingDeliveryMode::VirtualCube;
	}
	else if (SequenceSummary.bHasOpenPlan)
	{
		Summary.ClosureLabel = TEXT("open-active");
		Summary.RecommendedNextMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
	}
	else
	{
		Summary.ClosureLabel = Summary.bSuppressedBorderlineFollowUpByRecoveryHistory
			? TEXT("recommended-recovery-stable")
			: TEXT("sequence-stable");
		Summary.RecommendedNextMode = EHyperTwistTrainingDeliveryMode::Timer;
	}

	Summary.ClosureScore = FMath::Clamp(
		SequenceSummary.AverageOutcomeScore
		+ (static_cast<float>(Summary.ResolvedCaseCount) * 6.0f)
		- (static_cast<float>(Summary.PersistentWeakCaseCount) * 8.0f)
		- (static_cast<float>(Summary.UnresolvedCaseCount) * 10.0f)
		- (Summary.bNeedsEscalation ? 20.0f : 0.0f)
		- (Summary.bSpawnFollowUpFromSuppressionMemory ? 6.0f : 0.0f)
		+ (Summary.bSuppressedBorderlineFollowUpByRecoveryHistory ? 4.0f : 0.0f),
		0.0f,
		100.0f
	);

		return Summary;
	}
}

FHyperTwistTrainingCoachActionClosureSummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachActionClosureSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingCoachActionPlan& AnchorPlan,
	const FString& ReferenceUtc
)
{
	const FHyperTwistTrainingCoachActionPlan NormalizedAnchorPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(AnchorPlan);
	if (!NormalizedAnchorPlan.IsStructurallyValid())
	{
		return FHyperTwistTrainingCoachActionClosureSummary();
	}

	const FString ResolvedReferenceUtc =
		HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	const FHyperTwistTrainingCoachMemorySnapshot CoachMemorySnapshot =
		DeriveCoachMemorySnapshot(RepositoryState, NormalizedAnchorPlan.UserId, ResolvedReferenceUtc);
	return HyperTwistTrainingRepositoryLibraryInternal::DeriveCoachActionClosureSummaryWithCoachMemory(
		RepositoryState,
		NormalizedAnchorPlan,
		ResolvedReferenceUtc,
		CoachMemorySnapshot
	);
}

FHyperTwistTrainingCoachClosureMemorySummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachClosureMemorySummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachClosureMemorySummary Summary;
	if (UserId.IsEmpty())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingCoachActionPlan> UserPlans = ListCoachActionPlansForUser(RepositoryState, UserId);
	TMap<FString, FHyperTwistTrainingCoachActionPlan> LatestPlanByRootId;
	TMap<FString, FString> LatestSortUtcByRootId;

	for (const FHyperTwistTrainingCoachActionPlan& Plan : UserPlans)
	{
		const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(Plan);
		if (!NormalizedPlan.IsStructurallyValid())
		{
			continue;
		}

		const FString RootPlanId = !NormalizedPlan.RootPlanId.IsEmpty()
			? NormalizedPlan.RootPlanId
			: NormalizedPlan.PlanId;
		const FString SortUtc = !NormalizedPlan.CompletedAtUtc.IsEmpty()
			? NormalizedPlan.CompletedAtUtc
			: (!NormalizedPlan.StartedAtUtc.IsEmpty() ? NormalizedPlan.StartedAtUtc : NormalizedPlan.CreatedAtUtc);

		FHyperTwistTrainingCoachActionPlan* ExistingPlan = LatestPlanByRootId.Find(RootPlanId);
		FString* ExistingSortUtc = LatestSortUtcByRootId.Find(RootPlanId);
		if (ExistingPlan == nullptr || ExistingSortUtc == nullptr)
		{
			LatestPlanByRootId.Add(RootPlanId, NormalizedPlan);
			LatestSortUtcByRootId.Add(RootPlanId, SortUtc);
			continue;
		}

		const int32 CompareResult = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, *ExistingSortUtc);
		if (CompareResult > 0
			|| (CompareResult == 0 && NormalizedPlan.FollowUpDepth >= ExistingPlan->FollowUpDepth))
		{
			*ExistingPlan = NormalizedPlan;
			*ExistingSortUtc = SortUtc;
		}
	}

	float ClosureScoreAccumulator = 0.0f;
	int32 FocusPressureScore = -1;
	FString FocusSortUtc;
	TSet<FString> ArchivedResolvedCaseIds;
	TSet<FString> PersistentWeakCaseIds;
	TSet<FString> EscalationCaseIds;
	const FHyperTwistTrainingCoachMemorySnapshot CoachMemorySnapshot =
		HyperTwistTrainingRepositoryLibraryInternal::DeriveQueueRecoveryBiasSnapshot(
			RepositoryState,
			UserId,
			Summary.ReferenceUtc
		);

	for (const TPair<FString, FHyperTwistTrainingCoachActionPlan>& Pair : LatestPlanByRootId)
	{
		const FHyperTwistTrainingCoachActionClosureSummary ClosureSummary =
			HyperTwistTrainingRepositoryLibraryInternal::DeriveCoachActionClosureSummaryWithCoachMemory(
				RepositoryState,
				Pair.Value,
				Summary.ReferenceUtc,
				CoachMemorySnapshot
			);
		if (!ClosureSummary.IsStructurallyValid())
		{
			continue;
		}

		Summary.SequenceCount += 1;
		Summary.ClosedSequenceCount += ClosureSummary.bSequenceClosed ? 1 : 0;
		Summary.EscalatedSequenceCount += ClosureSummary.bNeedsEscalation ? 1 : 0;
		Summary.FollowUpReadySequenceCount += ClosureSummary.bShouldSpawnFollowUp ? 1 : 0;
		Summary.RecoverySustainedFollowUpSequenceCount +=
			ClosureSummary.bSpawnFollowUpFromSuppressionMemory ? 1 : 0;
		Summary.RecoverySuppressedBorderlineFollowUpSequenceCount +=
			ClosureSummary.bSuppressedBorderlineFollowUpByRecoveryHistory ? 1 : 0;
		ClosureScoreAccumulator += ClosureSummary.ClosureScore;

		if (ClosureSummary.bShouldArchiveResolvedCases)
		{
			for (const FString& CaseId : ClosureSummary.ResolvedCaseIds)
			{
				if (!CaseId.IsEmpty())
				{
					ArchivedResolvedCaseIds.Add(CaseId);
				}
			}
		}
		for (const FString& CaseId : ClosureSummary.PersistentWeakCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				PersistentWeakCaseIds.Add(CaseId);
			}
		}
		if (ClosureSummary.bNeedsEscalation)
		{
			for (const FString& CaseId : ClosureSummary.PersistentWeakCaseIds)
			{
				if (!CaseId.IsEmpty())
				{
					EscalationCaseIds.Add(CaseId);
				}
			}
			for (const FString& CaseId : ClosureSummary.UnresolvedCaseIds)
			{
				if (!CaseId.IsEmpty())
				{
					EscalationCaseIds.Add(CaseId);
				}
			}
		}

		const int32 CurrentPressureScore =
			(ClosureSummary.bNeedsEscalation ? 300 : 0)
			+ (ClosureSummary.bShouldSpawnFollowUp ? 200 : 0)
			+ (ClosureSummary.PersistentWeakCaseCount * 10)
			+ ClosureSummary.UnresolvedCaseCount;
		const FString SortUtc = !ClosureSummary.ReferenceUtc.IsEmpty()
			? ClosureSummary.ReferenceUtc
			: Summary.ReferenceUtc;
		const int32 TimeCompare = FocusSortUtc.IsEmpty()
			? 1
			: HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, FocusSortUtc);
		if (CurrentPressureScore > FocusPressureScore
			|| (CurrentPressureScore == FocusPressureScore && TimeCompare > 0))
		{
			FocusPressureScore = CurrentPressureScore;
			FocusSortUtc = SortUtc;
			Summary.FocusRootPlanId = ClosureSummary.RootPlanId;
			Summary.FocusDeckId = ClosureSummary.FocusDeckId;
			Summary.FocusMethodSegmentId = ClosureSummary.FocusMethodSegmentId;
			Summary.FocusClosureLabel = ClosureSummary.ClosureLabel;
		}
	}

	if (Summary.SequenceCount == 0)
	{
		return FHyperTwistTrainingCoachClosureMemorySummary();
	}

	Summary.ArchivedResolvedCaseIds = ArchivedResolvedCaseIds.Array();
	Summary.PersistentWeakCaseIds = PersistentWeakCaseIds.Array();
	Summary.EscalationCaseIds = EscalationCaseIds.Array();
	Summary.ArchivedResolvedCaseIds.Sort();
	Summary.PersistentWeakCaseIds.Sort();
	Summary.EscalationCaseIds.Sort();
	Summary.ArchivedResolvedCaseCount = Summary.ArchivedResolvedCaseIds.Num();
	Summary.PersistentWeakCaseCount = Summary.PersistentWeakCaseIds.Num();
	Summary.AverageClosureScore = ClosureScoreAccumulator / static_cast<float>(Summary.SequenceCount);
	Summary.bHasEscalationPressure = Summary.EscalatedSequenceCount > 0 || Summary.EscalationCaseIds.Num() > 0;
	Summary.bHasFollowUpPressure = Summary.FollowUpReadySequenceCount > 0;

	return Summary;
}

FHyperTwistTrainingCoachRecommendationHistorySummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachRecommendationHistorySummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachRecommendationHistorySummary Summary;
	if (UserId.IsEmpty())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingCoachActionPlan> UserPlans = ListCoachActionPlansForUser(RepositoryState, UserId);
	TMap<FString, FHyperTwistTrainingCoachActionPlan> LatestPlanByRootId;
	TMap<FString, FString> LatestSortUtcByRootId;
	TMap<FString, TSet<FString>> CaseIdsByRootPlanId;
	TMap<FString, int32> ActionCountByLabel;
	TMap<EHyperTwistTrainingDeliveryMode, int32> ModeCountMap;
	TMap<EHyperTwistTrainingSelectionPolicy, int32> PolicyCountMap;
	TMap<FString, int32> RecommendedCaseCounts;
	float FollowUpDepthAccumulator = 0.0f;
	float PlannedLaunchCaseCountAccumulator = 0.0f;
	int32 PlannedLaunchSampleCount = 0;
	float BroadenedLaunchOutcomeAccumulator = 0.0f;
	float TightenedLaunchOutcomeAccumulator = 0.0f;
	float DeferredTightenedLaunchOutcomeAccumulator = 0.0f;
	float DeferredFirstFollowUpPacketOutcomeAccumulator = 0.0f;
	float ReliableAlignedTrustedTightPlanOutcomeAccumulator = 0.0f;
	float ReliableAlignedTrustedBroadPlanOutcomeAccumulator = 0.0f;
	float ReliableAlignedTrustedTightFollowUpLaneOutcomeAccumulator = 0.0f;
	float ReliableAlignedTrustedBroadRecommendedLaneOutcomeAccumulator = 0.0f;
	float AlignedTightFollowUpPacketStructureOutcomeAccumulator = 0.0f;
	float AlignedBroadRecommendedPacketStructureOutcomeAccumulator = 0.0f;
	float AcceptedAlignedTightFollowUpPacketOutcomeAccumulator = 0.0f;
	float AcceptedAlignedBroadRecommendedPacketOutcomeAccumulator = 0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustOutcomeAccumulator = 0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustOutcomeAccumulator = 0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAccumulator = 0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAccumulator = 0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAccumulator = 0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAccumulator = 0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAccumulator = 0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAccumulator = 0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAccumulator = 0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAccumulator = 0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	float AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator =
		0.0f;
	FString LatestPlanSortUtc;

	for (const FHyperTwistTrainingCoachActionPlan& Plan : UserPlans)
	{
		const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(Plan);
		if (!NormalizedPlan.IsStructurallyValid())
		{
			continue;
		}

		Summary.PlanCount += 1;
		const bool bIsFollowUpLanePlan =
			NormalizedPlan.FollowUpDepth > 0 || !NormalizedPlan.ParentPlanId.IsEmpty();
		if (bIsFollowUpLanePlan)
		{
			Summary.FollowUpLanePlanCount += 1;
			Summary.FollowUpLaneContinueBias += 1;
		}
		else
		{
			Summary.RecommendedLanePlanCount += 1;
			Summary.RecommendedLaneContinueBias += 1;
		}
		FollowUpDepthAccumulator += static_cast<float>(NormalizedPlan.FollowUpDepth);
		ModeCountMap.FindOrAdd(NormalizedPlan.SuggestedMode) += 1;
		PolicyCountMap.FindOrAdd(NormalizedPlan.SuggestedSelectionPolicy) += 1;
		if (!NormalizedPlan.PrimaryActionLabel.IsEmpty())
		{
			ActionCountByLabel.FindOrAdd(NormalizedPlan.PrimaryActionLabel) += 1;
		}

		const FString RootPlanId = !NormalizedPlan.RootPlanId.IsEmpty()
			? NormalizedPlan.RootPlanId
			: NormalizedPlan.PlanId;
		TSet<FString>& RootCaseIds = CaseIdsByRootPlanId.FindOrAdd(RootPlanId);
		TSet<FString> UniquePlanCaseIds;
		for (const FString& FocusCaseId : NormalizedPlan.FocusCaseIds)
		{
			if (!FocusCaseId.IsEmpty())
			{
				UniquePlanCaseIds.Add(FocusCaseId);
			}
		}
		for (const FHyperTwistTrainingCoachActionPlanEntry& Entry : NormalizedPlan.Entries)
		{
			if (!Entry.CaseId.IsEmpty())
			{
				UniquePlanCaseIds.Add(Entry.CaseId);
			}
		}
		for (const FString& CaseId : UniquePlanCaseIds)
		{
			RecommendedCaseCounts.FindOrAdd(CaseId) += 1;
			RootCaseIds.Add(CaseId);
		}

		const FString SortUtc = !NormalizedPlan.CompletedAtUtc.IsEmpty()
			? NormalizedPlan.CompletedAtUtc
			: (!NormalizedPlan.StartedAtUtc.IsEmpty() ? NormalizedPlan.StartedAtUtc : NormalizedPlan.CreatedAtUtc);
		if (Summary.LatestPlanId.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, LatestPlanSortUtc) > 0
			|| (HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, LatestPlanSortUtc) == 0
				&& NormalizedPlan.PlanId > Summary.LatestPlanId))
		{
			Summary.LatestPlanId = NormalizedPlan.PlanId;
			Summary.FocusDeckId = NormalizedPlan.FocusDeckId;
			Summary.FocusMethodSegmentId = NormalizedPlan.FocusMethodSegmentId;
			LatestPlanSortUtc = SortUtc;
		}

		FHyperTwistTrainingCoachActionPlan* ExistingPlan = LatestPlanByRootId.Find(RootPlanId);
		FString* ExistingSortUtc = LatestSortUtcByRootId.Find(RootPlanId);
		if (ExistingPlan == nullptr || ExistingSortUtc == nullptr)
		{
			LatestPlanByRootId.Add(RootPlanId, NormalizedPlan);
			LatestSortUtcByRootId.Add(RootPlanId, SortUtc);
		}
		else
		{
			const int32 CompareResult = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				SortUtc,
				*ExistingSortUtc
			);
			if (CompareResult > 0
				|| (CompareResult == 0 && NormalizedPlan.FollowUpDepth >= ExistingPlan->FollowUpDepth))
			{
				*ExistingPlan = NormalizedPlan;
				*ExistingSortUtc = SortUtc;
			}
		}
	}

	if (Summary.PlanCount == 0)
	{
		return FHyperTwistTrainingCoachRecommendationHistorySummary();
	}

	int32 BestModeCount = -1;
	for (const TPair<EHyperTwistTrainingDeliveryMode, int32>& Pair : ModeCountMap)
	{
		if (Pair.Value > BestModeCount
			|| (Pair.Value == BestModeCount
				&& static_cast<uint8>(Pair.Key) < static_cast<uint8>(Summary.DominantSuggestedMode)))
		{
			BestModeCount = Pair.Value;
			Summary.DominantSuggestedMode = Pair.Key;
		}
	}

	int32 BestPolicyCount = -1;
	for (const TPair<EHyperTwistTrainingSelectionPolicy, int32>& Pair : PolicyCountMap)
	{
		if (Pair.Value > BestPolicyCount
			|| (Pair.Value == BestPolicyCount
				&& static_cast<uint8>(Pair.Key) < static_cast<uint8>(Summary.DominantSelectionPolicy)))
		{
			BestPolicyCount = Pair.Value;
			Summary.DominantSelectionPolicy = Pair.Key;
		}
	}

	int32 BestActionCount = -1;
	for (const TPair<FString, int32>& Pair : ActionCountByLabel)
	{
		if (Pair.Value > BestActionCount
			|| (Pair.Value == BestActionCount && Pair.Key < Summary.DominantPrimaryActionLabel))
		{
			BestActionCount = Pair.Value;
			Summary.DominantPrimaryActionLabel = Pair.Key;
		}
	}

	TSet<FString> RecurringCaseIds;
	for (const TPair<FString, int32>& Pair : RecommendedCaseCounts)
	{
		if (Pair.Value >= 2)
		{
			RecurringCaseIds.Add(Pair.Key);
		}
	}

	TSet<FString> ArchivedResolvedCaseIds;
	TSet<FString> EscalationCaseIds;
	float ClosureScoreAccumulator = 0.0f;
	int32 FocusPressureScore = -1;
	FString FocusPressureSortUtc;
	const FHyperTwistTrainingCoachMemorySnapshot CoachMemorySnapshot =
		HyperTwistTrainingRepositoryLibraryInternal::DeriveQueueRecoveryBiasSnapshot(
			RepositoryState,
			UserId,
			Summary.ReferenceUtc
		);

	for (const TPair<FString, FHyperTwistTrainingCoachActionPlan>& Pair : LatestPlanByRootId)
	{
		const FHyperTwistTrainingCoachActionPlanOutcomeSummary OutcomeSummary =
			UHyperTwistTrainingRepositoryLibrary::DeriveCoachActionPlanOutcomeSummary(
				RepositoryState,
				Pair.Value,
				Summary.ReferenceUtc
			);
		const FHyperTwistTrainingCoachActionClosureSummary ClosureSummary =
			HyperTwistTrainingRepositoryLibraryInternal::DeriveCoachActionClosureSummaryWithCoachMemory(
				RepositoryState,
				Pair.Value,
				Summary.ReferenceUtc,
				CoachMemorySnapshot
			);
		if (!ClosureSummary.IsStructurallyValid())
		{
			continue;
		}

		if (OutcomeSummary.IsStructurallyValid())
		{
			const EHyperTwistTrainingCoachGuidanceLane OutcomeGuidanceLane =
				Pair.Value.PreferredGuidanceLane != EHyperTwistTrainingCoachGuidanceLane::None
					? Pair.Value.PreferredGuidanceLane
					: (Pair.Value.FollowUpDepth > 0 || !Pair.Value.ParentPlanId.IsEmpty()
						? EHyperTwistTrainingCoachGuidanceLane::FollowUp
						: (OutcomeSummary.PreferredCoachHandoffKind
								== EHyperTwistTrainingCoachHandoffKind::FollowUp
							? EHyperTwistTrainingCoachGuidanceLane::FollowUp
							: (OutcomeSummary.PreferredCoachHandoffKind
									== EHyperTwistTrainingCoachHandoffKind::Recommended
								? EHyperTwistTrainingCoachGuidanceLane::Recommended
								: EHyperTwistTrainingCoachGuidanceLane::Recommended)));
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanCoachMemorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount += 1;
				ReliableAlignedTrustedTightPlanOutcomeAccumulator += OutcomeSummary.OutcomeScore;
				if (OutcomeGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::FollowUp)
				{
					Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount += 1;
					ReliableAlignedTrustedTightFollowUpLaneOutcomeAccumulator += OutcomeSummary.OutcomeScore;
				}
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanCoachMemorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount += 1;
				ReliableAlignedTrustedBroadPlanOutcomeAccumulator += OutcomeSummary.OutcomeScore;
				if (OutcomeGuidanceLane == EHyperTwistTrainingCoachGuidanceLane::Recommended)
				{
					Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount += 1;
					ReliableAlignedTrustedBroadRecommendedLaneOutcomeAccumulator += OutcomeSummary.OutcomeScore;
				}
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAlignedTightFollowUpPacketStructureCoachMemorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AlignedTightFollowUpPacketStructureOutcomeHistoryCount += 1;
				AlignedTightFollowUpPacketStructureOutcomeAccumulator += OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAlignedBroadRecommendedPacketStructureCoachMemorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount += 1;
				AlignedBroadRecommendedPacketStructureOutcomeAccumulator += OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeSource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount += 1;
				AcceptedAlignedTightFollowUpPacketOutcomeAccumulator += OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeSource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount += 1;
				AcceptedAlignedBroadRecommendedPacketOutcomeAccumulator += OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount += 1;
				AcceptedAlignedTightFollowUpPacketTrustOutcomeAccumulator += OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount += 1;
				AcceptedAlignedBroadRecommendedPacketTrustOutcomeAccumulator += OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeTrustSource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount += 1;
				AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketOutcomeAcceptedHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount += 1;
				AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeTrustSource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount += 1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketOutcomeAcceptedHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount += 1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactAcceptedHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount += 1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactAcceptedHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel)
				|| HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount += 1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedTightFollowUpPacketExactOutcomeReliableHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount += 1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (HyperTwistTrainingRepositoryLibraryInternal::IsReliableAcceptedAlignedBroadRecommendedPacketExactOutcomeReliableHistorySource(
					OutcomeSummary.PreferredCoachHandoffSourceLabel))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount += 1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-tight-follow-up-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PreferredCoachHandoffSourceLabel
				== TEXT("recommendation-history-accepted-aligned-broad-recommended-packet-reliable-exact-branch-dependability-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable")
					TEXT("-reliable"))
			{
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount +=
					1;
				AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator +=
					OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.PlannedLaunchCaseCount > 0)
			{
				PlannedLaunchCaseCountAccumulator +=
					static_cast<float>(OutcomeSummary.PlannedLaunchCaseCount);
				PlannedLaunchSampleCount += 1;
			}
			if (OutcomeSummary.bBroadenedLaunchBudget)
			{
				Summary.BroadenedLaunchPlanCount += 1;
				BroadenedLaunchOutcomeAccumulator += OutcomeSummary.OutcomeScore;
			}
			if (OutcomeSummary.bTightenedLaunchBudget)
			{
				Summary.TightenedLaunchPlanCount += 1;
				TightenedLaunchOutcomeAccumulator += OutcomeSummary.OutcomeScore;
				if (OutcomeSummary.DeferredLaunchCaseIds.Num() > 0)
				{
					Summary.DeferredTightenedLaunchPlanCount += 1;
					Summary.DeferredLaunchCaseCount += OutcomeSummary.DeferredLaunchCaseIds.Num();
					DeferredTightenedLaunchOutcomeAccumulator += OutcomeSummary.OutcomeScore;
					if (HyperTwistTrainingRepositoryLibraryInternal::IsDeferredFirstFollowUpPacket(Pair.Value))
					{
						Summary.DeferredFirstFollowUpPacketPlanCount += 1;
						DeferredFirstFollowUpPacketOutcomeAccumulator += OutcomeSummary.OutcomeScore;
					}
				}
			}
		}

		Summary.SequenceCount += 1;
		Summary.EscalatedSequenceCount += ClosureSummary.bNeedsEscalation ? 1 : 0;
		Summary.FollowUpReadySequenceCount += ClosureSummary.bShouldSpawnFollowUp ? 1 : 0;
		Summary.FollowUpLaneContinueBias += ClosureSummary.bShouldSpawnFollowUp ? 2 : 0;
		Summary.FollowUpLaneContinueBias += ClosureSummary.bNeedsEscalation ? 2 : 0;
		ClosureScoreAccumulator += ClosureSummary.ClosureScore;

		bool bHasRecurringCaseInSequence = false;
		if (const TSet<FString>* RootCaseIds = CaseIdsByRootPlanId.Find(Pair.Key))
		{
			for (const FString& CaseId : *RootCaseIds)
			{
				if (RecurringCaseIds.Contains(CaseId))
				{
					bHasRecurringCaseInSequence = true;
					break;
				}
			}
		}
		Summary.RepeatRecommendationSequenceCount += bHasRecurringCaseInSequence ? 1 : 0;
		Summary.RecommendedLaneContinueBias += bHasRecurringCaseInSequence ? 1 : 0;
		Summary.RecommendedLaneContinueBias +=
			(ClosureSummary.bSequenceClosed && !ClosureSummary.bShouldSpawnFollowUp) ? 1 : 0;

		if (ClosureSummary.bShouldArchiveResolvedCases)
		{
			for (const FString& CaseId : ClosureSummary.ResolvedCaseIds)
			{
				if (!CaseId.IsEmpty())
				{
					ArchivedResolvedCaseIds.Add(CaseId);
				}
			}
		}
		if (ClosureSummary.bNeedsEscalation)
		{
			for (const FString& CaseId : ClosureSummary.PersistentWeakCaseIds)
			{
				if (!CaseId.IsEmpty())
				{
					EscalationCaseIds.Add(CaseId);
				}
			}
			for (const FString& CaseId : ClosureSummary.UnresolvedCaseIds)
			{
				if (!CaseId.IsEmpty())
				{
					EscalationCaseIds.Add(CaseId);
				}
			}
		}

		const int32 CurrentPressureScore =
			(ClosureSummary.bNeedsEscalation ? 300 : 0)
			+ (ClosureSummary.bShouldSpawnFollowUp ? 200 : 0)
			+ (bHasRecurringCaseInSequence ? 100 : 0)
			+ (ClosureSummary.PersistentWeakCaseCount * 10)
			+ ClosureSummary.UnresolvedCaseCount;
		const FString SortUtc = !ClosureSummary.ReferenceUtc.IsEmpty()
			? ClosureSummary.ReferenceUtc
			: Summary.ReferenceUtc;
		const int32 TimeCompare = FocusPressureSortUtc.IsEmpty()
			? 1
			: HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, FocusPressureSortUtc);
		if (CurrentPressureScore > FocusPressureScore
			|| (CurrentPressureScore == FocusPressureScore && TimeCompare > 0))
		{
			FocusPressureScore = CurrentPressureScore;
			FocusPressureSortUtc = SortUtc;
			Summary.FocusDeckId = ClosureSummary.FocusDeckId;
			Summary.FocusMethodSegmentId = ClosureSummary.FocusMethodSegmentId;
		}
	}

	if (Summary.SequenceCount == 0)
	{
		return FHyperTwistTrainingCoachRecommendationHistorySummary();
	}

	Summary.RecurringCaseIds = RecurringCaseIds.Array();
	Summary.ArchivedResolvedCaseIds = ArchivedResolvedCaseIds.Array();
	Summary.EscalationCaseIds = EscalationCaseIds.Array();
	Summary.RecurringCaseIds.Sort();
	Summary.ArchivedResolvedCaseIds.Sort();
	Summary.EscalationCaseIds.Sort();
	Summary.RecurringCaseCount = Summary.RecurringCaseIds.Num();
	Summary.ArchivedResolvedCaseCount = Summary.ArchivedResolvedCaseIds.Num();
	Summary.EscalationCaseCount = Summary.EscalationCaseIds.Num();
	Summary.AverageClosureScore = ClosureScoreAccumulator / static_cast<float>(Summary.SequenceCount);
	Summary.AverageFollowUpDepth = FollowUpDepthAccumulator / static_cast<float>(Summary.PlanCount);
	if (PlannedLaunchSampleCount > 0)
	{
		Summary.AveragePlannedLaunchCaseCount =
			PlannedLaunchCaseCountAccumulator / static_cast<float>(PlannedLaunchSampleCount);
	}
	if (Summary.BroadenedLaunchPlanCount > 0)
	{
		Summary.BroadenedLaunchAverageOutcomeScore =
			BroadenedLaunchOutcomeAccumulator / static_cast<float>(Summary.BroadenedLaunchPlanCount);
	}
	if (Summary.TightenedLaunchPlanCount > 0)
	{
		Summary.TightenedLaunchAverageOutcomeScore =
			TightenedLaunchOutcomeAccumulator / static_cast<float>(Summary.TightenedLaunchPlanCount);
	}
	if (Summary.DeferredTightenedLaunchPlanCount > 0)
	{
		Summary.DeferredTightenedLaunchAverageOutcomeScore =
			DeferredTightenedLaunchOutcomeAccumulator
			/ static_cast<float>(Summary.DeferredTightenedLaunchPlanCount);
	}
	if (Summary.DeferredFirstFollowUpPacketPlanCount > 0)
	{
		Summary.DeferredFirstFollowUpPacketAverageOutcomeScore =
			DeferredFirstFollowUpPacketOutcomeAccumulator
			/ static_cast<float>(Summary.DeferredFirstFollowUpPacketPlanCount);
	}
	if (Summary.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount > 0)
	{
		Summary.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeAverageScore =
			ReliableAlignedTrustedTightPlanOutcomeAccumulator
			/ static_cast<float>(
				Summary.ReliableAlignedTrustedTightMethodDrillRecoveryStructurePlanOutcomeHistoryCount);
	}
	if (Summary.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount > 0)
	{
		Summary.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeAverageScore =
			ReliableAlignedTrustedBroadPlanOutcomeAccumulator
			/ static_cast<float>(
				Summary.ReliableAlignedTrustedBroadMethodDrillRecoveryStructurePlanOutcomeHistoryCount);
	}
	if (Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount > 0)
	{
		Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore =
			ReliableAlignedTrustedTightFollowUpLaneOutcomeAccumulator
			/ static_cast<float>(Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount);
	}
	if (Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount > 0)
	{
		Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore =
			ReliableAlignedTrustedBroadRecommendedLaneOutcomeAccumulator
			/ static_cast<float>(
				Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount);
	}
	if (Summary.AlignedTightFollowUpPacketStructureOutcomeHistoryCount > 0)
	{
		Summary.AlignedTightFollowUpPacketStructureOutcomeAverageScore =
			AlignedTightFollowUpPacketStructureOutcomeAccumulator
			/ static_cast<float>(Summary.AlignedTightFollowUpPacketStructureOutcomeHistoryCount);
	}
	if (Summary.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount > 0)
	{
		Summary.AlignedBroadRecommendedPacketStructureOutcomeAverageScore =
			AlignedBroadRecommendedPacketStructureOutcomeAccumulator
			/ static_cast<float>(Summary.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore =
			AcceptedAlignedTightFollowUpPacketOutcomeAccumulator
			/ static_cast<float>(Summary.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore =
			AcceptedAlignedBroadRecommendedPacketOutcomeAccumulator
			/ static_cast<float>(Summary.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustOutcomeAccumulator
			/ static_cast<float>(Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustOutcomeAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount > 0)
	{
		Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount);
	}
	if (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount > 0)
	{
		Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount);
	}
	if (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount > 0)
	{
		Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAccumulator
			/ static_cast<float>(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount);
	}
	if (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount
		> 0)
	{
		Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount);
	}
	if (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount
		> 0)
	{
		Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	if (Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
		> 0)
	{
		Summary
			.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore =
			AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAccumulator
			/ static_cast<float>(
				Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount);
	}
	const int32 AcceptedAlignedTightPacketOutcomeLaneSignal =
		(Summary.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore >= 60.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
					- Summary.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
					+ (Summary.AcceptedAlignedTightFollowUpPacketOutcomeAverageScore >= 80.0f ? 1 : 0),
				1,
				4)
			: 0;
	const int32 AcceptedAlignedBroadPacketOutcomeLaneSignal =
		(Summary.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore >= 58.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedBroadRecommendedPacketOutcomeHistoryCount
					- Summary.AcceptedAlignedTightFollowUpPacketOutcomeHistoryCount
					+ (Summary.AcceptedAlignedBroadRecommendedPacketOutcomeAverageScore >= 78.0f ? 1 : 0),
				1,
				4)
			: 0;
	const int32 AcceptedAlignedTightPacketTrustOutcomeLaneSignal =
		(Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore >= 65.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount
					- Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount
					+ (Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeAverageScore >= 82.0f
						? 1
						: 0),
				1,
				3)
			: 0;
	const int32 AcceptedAlignedBroadPacketTrustOutcomeLaneSignal =
		(Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore >= 63.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeHistoryCount
					- Summary.AcceptedAlignedTightFollowUpPacketTrustOutcomeHistoryCount
					+ (Summary.AcceptedAlignedBroadRecommendedPacketTrustOutcomeAverageScore >= 80.0f
						? 1
						: 0),
				1,
				3)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableOutcomeLaneSignal =
		(Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore >= 68.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
					- Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
					+ (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeAverageScore
							>= 84.0f
						? 1
						: 0),
				1,
				4)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableOutcomeLaneSignal =
		(Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore >= 66.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeHistoryCount
					- Summary.AcceptedAlignedTightFollowUpPacketTrustReliableOutcomeHistoryCount
					+ (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableOutcomeAverageScore
							>= 82.0f
						? 1
						: 0),
				1,
				4)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeLaneSignal =
		(Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAverageScore
				>= 70.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount
					- Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount
					+ (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeAverageScore
							>= 86.0f
						? 1
						: 0),
				1,
				4)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeLaneSignal =
		(Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAverageScore
				>= 68.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeHistoryCount
					- Summary.AcceptedAlignedTightFollowUpPacketTrustReliableLaneOutcomeHistoryCount
					+ (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableLaneOutcomeAverageScore
							>= 84.0f
						? 1
						: 0),
				1,
				4)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeHistorySignal =
		(Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAverageScore
				>= 72.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount
					- Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount
					+ (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeAverageScore
							>= 88.0f
						? 1
						: 0),
				1,
				5)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeHistorySignal =
		(Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount >= 2
			&& Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAverageScore
				>= 70.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeHistoryCount
					- Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeHistoryCount
					+ (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeAverageScore
							>= 86.0f
						? 1
						: 0),
				1,
				5)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableSignal =
		(Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount >= 2
			&& Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore
				>= 70.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
					- Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
					+ (Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableAverageScore
							>= 86.0f
						? 1
						: 0),
				1,
				6)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableSignal =
		(Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
				>= 2
			&& Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore
				>= 68.0f)
			? FMath::Clamp(
				Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableHistoryCount
					- Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableHistoryCount
					+ (Summary.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableAverageScore
							>= 84.0f
						? 1
						: 0),
				1,
				6)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableSignal =
		(Summary.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount
				>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAverageScore
				>= 72.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableAverageScore
						   >= 88.0f
						? 1
						: 0),
				1,
				7)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAverageScore
				>= 70.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableAverageScore
						   >= 86.0f
						? 1
						: 0),
				1,
				7)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
				>= 74.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
						   >= 89.0f
						? 1
						: 0),
				1,
				8)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
				>= 72.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableAverageScore
						   >= 87.0f
						? 1
						: 0),
				1,
				8)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
				>= 76.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
						   >= 90.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
				>= 74.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableAverageScore
						   >= 88.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
				>= 78.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
						   >= 92.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
				>= 76.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableAverageScore
						   >= 90.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 80.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 94.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 78.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 92.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 82.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 96.0f
						? 1
						: 0),
				1,
				12)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 80.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 94.0f
						? 1
						: 0),
				1,
				12)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 84.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 98.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 82.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 96.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				14)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 84.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 98.0f
						? 1
						: 0),
				1,
				14)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				15)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				15)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 84.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 82.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 98.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				14)
			: 0;
	const int32 AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 84.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				14)
			: 0;
	const int32 AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierTightSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierBroadSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
					1,
					16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				17)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				16)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				15)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 84.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				15)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				14)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				14)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 84.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				13)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				12)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				12)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				11)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 94.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 94.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 94.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 94.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 94.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				9)
			: 0;
	const int32 TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 92.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 90.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				10)
			: 0;
	const int32 HighestExactOutcomeTierAcceptedAlignedTightCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 88.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				15)
			: 0;
	const int32 HighestExactOutcomeTierAcceptedAlignedBroadCompletionSummarySignal =
		(Summary
				 .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					>= 2
			&& Summary
					.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
				>= 86.0f)
			? FMath::Clamp(
				Summary
						.AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					- Summary
							.AcceptedAlignedTightFollowUpPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedHistoryCount
					+ (Summary
							   .AcceptedAlignedBroadRecommendedPacketTrustReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedAverageScore
						   >= 100.0f
						? 1
						: 0),
				1,
				15)
			: 0;
	if (AcceptedAlignedTightPacketOutcomeLaneSignal > AcceptedAlignedBroadPacketOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
	}
	else if (AcceptedAlignedBroadPacketOutcomeLaneSignal > AcceptedAlignedTightPacketOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
	}
	if (AcceptedAlignedTightPacketTrustOutcomeLaneSignal
		> AcceptedAlignedBroadPacketTrustOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
	}
	else if (AcceptedAlignedBroadPacketTrustOutcomeLaneSignal
		> AcceptedAlignedTightPacketTrustOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
	}
	if (AcceptedAlignedTightPacketReliableOutcomeLaneSignal
		> AcceptedAlignedBroadPacketReliableOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias += AcceptedAlignedTightPacketReliableOutcomeLaneSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableOutcomeLaneSignal
		> AcceptedAlignedTightPacketReliableOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias += AcceptedAlignedBroadPacketReliableOutcomeLaneSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeLaneSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias += AcceptedAlignedTightPacketReliableExactOutcomeLaneSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeLaneSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeLaneSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeLaneSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeHistorySignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeHistorySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeHistorySignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeHistorySignal
		> AcceptedAlignedTightPacketReliableExactOutcomeHistorySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeHistorySignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	else if (AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		> AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal;
	}
	if (AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeSummarySignal
		> AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeSummarySignal;
	}
	else if (AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeSummarySignal
		> AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierTightSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierBroadSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierTightSummarySignal;
	}
	else if (HighestExactCompletionReliabilityOutcomeTierBroadSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierTightSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierBroadSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSummarySignal;
	}
	else if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSummarySignal
		> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSummarySignal;
	}
	else if (
		TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSummarySignal
		> TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSummarySignal;
	}
	if (TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSummarySignal
		> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSummarySignal;
	}
	else if (
		TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSummarySignal
		> TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSummarySignal;
	}
	if (TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal
		> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal
		> TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal;
	}
	if (HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	else if (
		HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal;
	}
	if (HighestExactOutcomeTierAcceptedAlignedTightCompletionSummarySignal
		> HighestExactOutcomeTierAcceptedAlignedBroadCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::Timer
			|| Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::VirtualCube)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::CoachReviewed;
		}
		Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Scripted;
		Summary.FollowUpLaneContinueBias +=
			HighestExactOutcomeTierAcceptedAlignedTightCompletionSummarySignal;
	}
	else if (HighestExactOutcomeTierAcceptedAlignedBroadCompletionSummarySignal
		> HighestExactOutcomeTierAcceptedAlignedTightCompletionSummarySignal)
	{
		if (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed
			&& Summary.EscalatedSequenceCount == 0
			&& Summary.FollowUpReadySequenceCount == 0)
		{
			Summary.DominantSuggestedMode = EHyperTwistTrainingDeliveryMode::Timer;
		}
		if (Summary.DominantSelectionPolicy == EHyperTwistTrainingSelectionPolicy::Scripted)
		{
			Summary.DominantSelectionPolicy = EHyperTwistTrainingSelectionPolicy::Weighted;
		}
		Summary.RecommendedLaneContinueBias +=
			HighestExactOutcomeTierAcceptedAlignedBroadCompletionSummarySignal;
	}
	Summary.bHasRepeatRecommendationPressure =
		Summary.RepeatRecommendationSequenceCount > 0
		&& (Summary.RecurringCaseCount > 0
			|| Summary.FollowUpReadySequenceCount > 0
			|| Summary.EscalatedSequenceCount > 0);
	Summary.bShouldBiasCoachReviewed =
		Summary.EscalatedSequenceCount > 0
		|| Summary.RepeatRecommendationSequenceCount >= 2
		|| AcceptedAlignedTightPacketOutcomeLaneSignal > AcceptedAlignedBroadPacketOutcomeLaneSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableAcceptedSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
			> AcceptedAlignedBroadPacketReliableExactOutcomeReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableReliableSignal
		|| AcceptedAlignedTightPacketHighestCompletionReliabilityOutcomeSummarySignal
			> AcceptedAlignedBroadPacketHighestCompletionReliabilityOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierTightSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierBroadSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeSummarySignal
		|| HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedTightCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
			> HighestExactCompletionReliabilityOutcomeTierAcceptedAlignedBroadCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionOutcomeCompletionSummarySignal
		|| TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeSummarySignal
			> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeSummarySignal
		|| TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionSummarySignal
			> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionSummarySignal
		|| TopAcceptedAlignedTightPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal
			> TopAcceptedAlignedBroadPacketCompletionReliabilityOutcomeCompletionOutcomeSummarySignal
		|| HighestExactOutcomeTierAcceptedAlignedTightCompletionSummarySignal
			> HighestExactOutcomeTierAcceptedAlignedBroadCompletionSummarySignal
		|| (Summary.bHasRepeatRecommendationPressure
			&& Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed);

	const bool bHasFollowUpLaneSignal =
		Summary.FollowUpLanePlanCount > 0
		|| Summary.FollowUpReadySequenceCount > 0
		|| Summary.EscalatedSequenceCount > 0
		|| Summary.DeferredTightenedLaunchPlanCount > 0
		|| Summary.AverageFollowUpDepth >= 1.0f;
	const float RecommendedLaneScore =
		1.0f
		+ static_cast<float>(Summary.RecommendedLaneContinueBias)
		+ static_cast<float>(Summary.RepeatRecommendationSequenceCount) * 1.5f
		+ (Summary.bHasRepeatRecommendationPressure ? 2.0f : 0.0f)
		+ (Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed ? 1.0f : 0.0f);
	const float FollowUpLaneScore =
		1.0f
		+ static_cast<float>(Summary.FollowUpLaneContinueBias)
		+ static_cast<float>(Summary.FollowUpReadySequenceCount) * 2.0f
		+ static_cast<float>(Summary.EscalatedSequenceCount) * 1.5f
		+ static_cast<float>(Summary.DeferredTightenedLaunchPlanCount) * 1.5f
		+ static_cast<float>(Summary.DeferredFirstFollowUpPacketPlanCount) * 1.5f
		+ FMath::Clamp(static_cast<float>(Summary.DeferredLaunchCaseCount) * 0.25f, 0.0f, 4.0f)
		+ Summary.AverageFollowUpDepth;
	const int32 ReliableAlignedTrustedTightFollowUpLaneSignal =
		(Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount >= 2
			&& Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore >= 60.0f)
			? FMath::Clamp(
				Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount
					- Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount
					+ (Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeAverageScore >= 80.0f ? 1 : 0),
				1,
				4)
			: 0;
	const int32 ReliableAlignedTrustedBroadRecommendedLaneSignal =
		(Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount >= 2
			&& Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore >= 58.0f)
			? FMath::Clamp(
				Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeHistoryCount
					- Summary.ReliableAlignedTrustedTightFollowUpGuidanceOutcomeHistoryCount
					+ (Summary.ReliableAlignedTrustedBroadRecommendedGuidanceOutcomeAverageScore >= 78.0f ? 1 : 0),
				1,
				4)
			: 0;
	const int32 AlignedTightPacketStructureOutcomeLaneSignal =
		(Summary.AlignedTightFollowUpPacketStructureOutcomeHistoryCount >= 2
			&& Summary.AlignedTightFollowUpPacketStructureOutcomeAverageScore >= 60.0f)
			? FMath::Clamp(
				Summary.AlignedTightFollowUpPacketStructureOutcomeHistoryCount
					- Summary.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount
					+ (Summary.AlignedTightFollowUpPacketStructureOutcomeAverageScore >= 78.0f ? 1 : 0),
				1,
				4)
			: 0;
	const int32 AlignedBroadPacketStructureOutcomeLaneSignal =
		(Summary.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount >= 2
			&& Summary.AlignedBroadRecommendedPacketStructureOutcomeAverageScore >= 58.0f)
			? FMath::Clamp(
				Summary.AlignedBroadRecommendedPacketStructureOutcomeHistoryCount
					- Summary.AlignedTightFollowUpPacketStructureOutcomeHistoryCount
					+ (Summary.AlignedBroadRecommendedPacketStructureOutcomeAverageScore >= 76.0f ? 1 : 0),
				1,
				4)
			: 0;
	Summary.PreferredGuidanceLane =
		bHasFollowUpLaneSignal
			&& (FollowUpLaneScore
					+ static_cast<float>(ReliableAlignedTrustedTightFollowUpLaneSignal) * 1.5f
					+ static_cast<float>(AlignedTightPacketStructureOutcomeLaneSignal) * 1.25f
					+ static_cast<float>(AcceptedAlignedTightPacketOutcomeLaneSignal) * 1.5f)
				> (RecommendedLaneScore
					+ static_cast<float>(ReliableAlignedTrustedBroadRecommendedLaneSignal) * 1.5f
					+ static_cast<float>(AlignedBroadPacketStructureOutcomeLaneSignal) * 1.25f
					+ static_cast<float>(AcceptedAlignedBroadPacketOutcomeLaneSignal) * 1.5f)
			? EHyperTwistTrainingCoachGuidanceLane::FollowUp
			: EHyperTwistTrainingCoachGuidanceLane::Recommended;

	return Summary;
}

FHyperTwistTrainingCoachCarryForwardPolicySummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachCarryForwardPolicySummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachCarryForwardPolicySummary Summary;
	if (UserId.IsEmpty())
	{
		return Summary;
	}

	const FHyperTwistTrainingCoachClosureMemorySummary ClosureMemory =
		DeriveCoachClosureMemorySummary(RepositoryState, UserId, ReferenceUtc);
	const FHyperTwistTrainingCoachRecommendationHistorySummary RecommendationHistory =
		DeriveCoachRecommendationHistorySummary(RepositoryState, UserId, ReferenceUtc);
	if (!ClosureMemory.IsStructurallyValid() && !RecommendationHistory.IsStructurallyValid())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	Summary.FocusDeckId = !RecommendationHistory.FocusDeckId.IsEmpty()
		? RecommendationHistory.FocusDeckId
		: ClosureMemory.FocusDeckId;
	Summary.FocusMethodSegmentId = !RecommendationHistory.FocusMethodSegmentId.IsEmpty()
		? RecommendationHistory.FocusMethodSegmentId
		: ClosureMemory.FocusMethodSegmentId;
	Summary.DominantSuggestedMode = RecommendationHistory.IsStructurallyValid()
		? RecommendationHistory.DominantSuggestedMode
		: EHyperTwistTrainingDeliveryMode::Timer;
	Summary.DominantSelectionPolicy = RecommendationHistory.IsStructurallyValid()
		? RecommendationHistory.DominantSelectionPolicy
		: EHyperTwistTrainingSelectionPolicy::Weighted;

	TSet<FString> RecurringCarryForwardCaseIds;
	TSet<FString> EscalationCarryForwardCaseIds;
	TSet<FString> PinnedCarryForwardCaseIds;
	TSet<FString> SuppressedResolvedCaseIds;

	for (const FString& CaseId : RecommendationHistory.RecurringCaseIds)
	{
		if (!CaseId.IsEmpty())
		{
			RecurringCarryForwardCaseIds.Add(CaseId);
			PinnedCarryForwardCaseIds.Add(CaseId);
		}
	}
	for (const FString& CaseId : ClosureMemory.EscalationCaseIds)
	{
		if (!CaseId.IsEmpty())
		{
			EscalationCarryForwardCaseIds.Add(CaseId);
			PinnedCarryForwardCaseIds.Add(CaseId);
		}
	}
	for (const FString& CaseId : RecommendationHistory.EscalationCaseIds)
	{
		if (!CaseId.IsEmpty())
		{
			EscalationCarryForwardCaseIds.Add(CaseId);
			PinnedCarryForwardCaseIds.Add(CaseId);
		}
	}
	for (const FString& CaseId : ClosureMemory.PersistentWeakCaseIds)
	{
		if (!CaseId.IsEmpty())
		{
			PinnedCarryForwardCaseIds.Add(CaseId);
		}
	}
	for (const FString& CaseId : ClosureMemory.ArchivedResolvedCaseIds)
	{
		if (!CaseId.IsEmpty() && !PinnedCarryForwardCaseIds.Contains(CaseId))
		{
			SuppressedResolvedCaseIds.Add(CaseId);
		}
	}

	Summary.RecurringCarryForwardCaseIds = RecurringCarryForwardCaseIds.Array();
	Summary.EscalationCarryForwardCaseIds = EscalationCarryForwardCaseIds.Array();
	Summary.PinnedCarryForwardCaseIds = PinnedCarryForwardCaseIds.Array();
	Summary.SuppressedResolvedCaseIds = SuppressedResolvedCaseIds.Array();
	Summary.RecurringCarryForwardCaseIds.Sort();
	Summary.EscalationCarryForwardCaseIds.Sort();
	Summary.PinnedCarryForwardCaseIds.Sort();
	Summary.SuppressedResolvedCaseIds.Sort();
	Summary.RecurringCarryForwardCaseCount = Summary.RecurringCarryForwardCaseIds.Num();
	Summary.EscalationCarryForwardCaseCount = Summary.EscalationCarryForwardCaseIds.Num();
	Summary.PinnedCarryForwardCaseCount = Summary.PinnedCarryForwardCaseIds.Num();
	Summary.SuppressedResolvedCaseCount = Summary.SuppressedResolvedCaseIds.Num();

	Summary.bSuppressResolvedResurfacing = Summary.SuppressedResolvedCaseCount > 0;
	Summary.bPinRecurringCases = Summary.PinnedCarryForwardCaseCount > 0;
	Summary.bNeedsEscalationHandOff =
		ClosureMemory.bHasEscalationPressure || Summary.EscalationCarryForwardCaseCount > 0;
	Summary.bBiasCoachReviewed =
		Summary.bNeedsEscalationHandOff
		|| RecommendationHistory.bShouldBiasCoachReviewed
		|| (Summary.PinnedCarryForwardCaseCount > 0
			&& Summary.DominantSuggestedMode == EHyperTwistTrainingDeliveryMode::CoachReviewed);
	Summary.bHasActiveCarryForwardPressure =
		Summary.bNeedsEscalationHandOff
		|| Summary.bPinRecurringCases
		|| RecommendationHistory.bHasRepeatRecommendationPressure
		|| ClosureMemory.bHasFollowUpPressure;

	Summary.CarryForwardIntensityScore = FMath::Clamp(
		(static_cast<float>(Summary.EscalationCarryForwardCaseCount) * 25.0f)
		+ (static_cast<float>(Summary.RecurringCarryForwardCaseCount) * 12.0f)
		+ (static_cast<float>(RecommendationHistory.RepeatRecommendationSequenceCount) * 8.0f)
		+ (ClosureMemory.bHasFollowUpPressure ? 10.0f : 0.0f)
		- (static_cast<float>(Summary.SuppressedResolvedCaseCount) * 2.0f),
		0.0f,
		100.0f
	);

	return Summary;
}

FHyperTwistTrainingCoachArchivePolicySummary UHyperTwistTrainingRepositoryLibrary::DeriveCoachArchivePolicySummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingCoachArchivePolicySummary Summary;
	if (UserId.IsEmpty())
	{
		return Summary;
	}

	const FHyperTwistTrainingCoachClosureMemorySummary ClosureMemory =
		DeriveCoachClosureMemorySummary(RepositoryState, UserId, ReferenceUtc);
	const FHyperTwistTrainingCoachRecommendationHistorySummary RecommendationHistory =
		DeriveCoachRecommendationHistorySummary(RepositoryState, UserId, ReferenceUtc);
	const FHyperTwistTrainingCoachCarryForwardPolicySummary CarryForwardPolicy =
		DeriveCoachCarryForwardPolicySummary(RepositoryState, UserId, ReferenceUtc);
	if (!ClosureMemory.IsStructurallyValid()
		&& !RecommendationHistory.IsStructurallyValid()
		&& !CarryForwardPolicy.IsStructurallyValid())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);
	Summary.FocusDeckId = CarryForwardPolicy.IsStructurallyValid()
		? CarryForwardPolicy.FocusDeckId
		: (!RecommendationHistory.FocusDeckId.IsEmpty() ? RecommendationHistory.FocusDeckId : ClosureMemory.FocusDeckId);
	Summary.FocusMethodSegmentId = CarryForwardPolicy.IsStructurallyValid()
		? CarryForwardPolicy.FocusMethodSegmentId
		: (!RecommendationHistory.FocusMethodSegmentId.IsEmpty()
			? RecommendationHistory.FocusMethodSegmentId
			: ClosureMemory.FocusMethodSegmentId);
	Summary.DominantSuggestedMode = CarryForwardPolicy.IsStructurallyValid()
		? CarryForwardPolicy.DominantSuggestedMode
		: RecommendationHistory.DominantSuggestedMode;
	Summary.DominantSelectionPolicy = CarryForwardPolicy.IsStructurallyValid()
		? CarryForwardPolicy.DominantSelectionPolicy
		: RecommendationHistory.DominantSelectionPolicy;

	const TArray<FHyperTwistTrainingCoachActionPlan> UserPlans = ListCoachActionPlansForUser(RepositoryState, UserId);
	TMap<FString, FHyperTwistTrainingCoachActionPlan> LatestPlanByRootId;
	TMap<FString, FString> LatestSortUtcByRootId;

	for (const FHyperTwistTrainingCoachActionPlan& Plan : UserPlans)
	{
		const FHyperTwistTrainingCoachActionPlan NormalizedPlan =
			HyperTwistTrainingRepositoryLibraryInternal::NormalizeCoachActionPlan(Plan);
		if (!NormalizedPlan.IsStructurallyValid())
		{
			continue;
		}

		const FString RootPlanId = !NormalizedPlan.RootPlanId.IsEmpty()
			? NormalizedPlan.RootPlanId
			: NormalizedPlan.PlanId;
		const FString SortUtc = !NormalizedPlan.CompletedAtUtc.IsEmpty()
			? NormalizedPlan.CompletedAtUtc
			: (!NormalizedPlan.StartedAtUtc.IsEmpty() ? NormalizedPlan.StartedAtUtc : NormalizedPlan.CreatedAtUtc);

		FHyperTwistTrainingCoachActionPlan* ExistingPlan = LatestPlanByRootId.Find(RootPlanId);
		FString* ExistingSortUtc = LatestSortUtcByRootId.Find(RootPlanId);
		if (ExistingPlan == nullptr || ExistingSortUtc == nullptr)
		{
			LatestPlanByRootId.Add(RootPlanId, NormalizedPlan);
			LatestSortUtcByRootId.Add(RootPlanId, SortUtc);
			continue;
		}

		const int32 CompareResult = HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(SortUtc, *ExistingSortUtc);
		if (CompareResult > 0
			|| (CompareResult == 0 && NormalizedPlan.FollowUpDepth >= ExistingPlan->FollowUpDepth))
		{
			*ExistingPlan = NormalizedPlan;
			*ExistingSortUtc = SortUtc;
		}
	}

	TMap<FString, int32> ResolvedArchiveHitCounts;
	TMap<FString, int32> OpenCarryForwardHitCounts;
	TMap<FString, int32> EscalationHitCounts;
	TMap<FString, int32> StableArchiveHitCounts;
	const FHyperTwistTrainingCoachMemorySnapshot CoachMemorySnapshot =
		HyperTwistTrainingRepositoryLibraryInternal::DeriveQueueRecoveryBiasSnapshot(
			RepositoryState,
			UserId,
			Summary.ReferenceUtc
		);

	for (const TPair<FString, FHyperTwistTrainingCoachActionPlan>& Pair : LatestPlanByRootId)
	{
		const FHyperTwistTrainingCoachActionClosureSummary ClosureSummary =
			HyperTwistTrainingRepositoryLibraryInternal::DeriveCoachActionClosureSummaryWithCoachMemory(
				RepositoryState,
				Pair.Value,
				Summary.ReferenceUtc,
				CoachMemorySnapshot
			);
		if (!ClosureSummary.IsStructurallyValid())
		{
			continue;
		}

		if (ClosureSummary.bShouldArchiveResolvedCases)
		{
			for (const FString& CaseId : ClosureSummary.ResolvedCaseIds)
			{
				if (CaseId.IsEmpty())
				{
					continue;
				}

				ResolvedArchiveHitCounts.FindOrAdd(CaseId) += 1;
				if (ClosureSummary.bSequenceClosed
					&& !ClosureSummary.bNeedsEscalation
					&& !ClosureSummary.bShouldSpawnFollowUp)
				{
					StableArchiveHitCounts.FindOrAdd(CaseId) += 1;
				}
			}
		}

		for (const FString& CaseId : ClosureSummary.PersistentWeakCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				OpenCarryForwardHitCounts.FindOrAdd(CaseId) += 1;
				if (ClosureSummary.bNeedsEscalation)
				{
					EscalationHitCounts.FindOrAdd(CaseId) += 1;
				}
			}
		}
		for (const FString& CaseId : ClosureSummary.UnresolvedCaseIds)
		{
			if (!CaseId.IsEmpty())
			{
				OpenCarryForwardHitCounts.FindOrAdd(CaseId) += 1;
				if (ClosureSummary.bNeedsEscalation)
				{
					EscalationHitCounts.FindOrAdd(CaseId) += 1;
				}
			}
		}
	}

	TSet<FString> RecurringCaseIds;
	for (const FString& CaseId : RecommendationHistory.RecurringCaseIds)
	{
		if (!CaseId.IsEmpty())
		{
			RecurringCaseIds.Add(CaseId);
		}
	}

	TSet<FString> LongTermArchivedCaseIds;
	TSet<FString> ExpiredCarryForwardCaseIds;
	TSet<FString> RetainedCarryForwardCaseIds;
	TSet<FString> EscalationRetainedCaseIds;
	TSet<FString> SuppressedResolvedCaseIds;
	TSet<FString> StableLongTermArchivedCaseIds;
	TSet<FString> ProvisionalArchivedCaseIds;
	TSet<FString> ReopenRiskArchivedCaseIds;

	for (const FString& CaseId : CarryForwardPolicy.SuppressedResolvedCaseIds)
	{
		if (!CaseId.IsEmpty())
		{
			LongTermArchivedCaseIds.Add(CaseId);
			SuppressedResolvedCaseIds.Add(CaseId);

			const int32 OpenCarryForwardHits = OpenCarryForwardHitCounts.FindRef(CaseId);
			const int32 StableArchiveHits = StableArchiveHitCounts.FindRef(CaseId);
			const bool bRecurringCase = RecurringCaseIds.Contains(CaseId);
			if (StableArchiveHits > 0 && OpenCarryForwardHits == 0 && !bRecurringCase)
			{
				StableLongTermArchivedCaseIds.Add(CaseId);
			}
			else
			{
				ProvisionalArchivedCaseIds.Add(CaseId);
				if (bRecurringCase || OpenCarryForwardHits > 0)
				{
					ReopenRiskArchivedCaseIds.Add(CaseId);
				}
			}
		}
	}

	const bool bStableClosureMemory =
		ClosureMemory.AverageClosureScore >= 70.0f
		&& !ClosureMemory.bHasEscalationPressure
		&& !ClosureMemory.bHasFollowUpPressure;

	for (const FString& CaseId : CarryForwardPolicy.PinnedCarryForwardCaseIds)
	{
		if (CaseId.IsEmpty())
		{
			continue;
		}

		const int32 ResolvedArchiveHits = ResolvedArchiveHitCounts.FindRef(CaseId);
		const int32 OpenCarryForwardHits = OpenCarryForwardHitCounts.FindRef(CaseId);
		const int32 EscalationHits = EscalationHitCounts.FindRef(CaseId);
		const int32 StableArchiveHits = StableArchiveHitCounts.FindRef(CaseId);
		const bool bRecurringCase = RecurringCaseIds.Contains(CaseId);

		const bool bCanExpireResolvedCarryForward =
			EscalationHits == 0
			&& ResolvedArchiveHits > 0
			&& OpenCarryForwardHits <= ResolvedArchiveHits
			&& (StableArchiveHits > 0
				|| bStableClosureMemory
				|| (ResolvedArchiveHits >= 2 && !bRecurringCase)
				|| (ResolvedArchiveHits > OpenCarryForwardHits
					&& RecommendationHistory.RepeatRecommendationSequenceCount <= 1));

		if (bCanExpireResolvedCarryForward)
		{
			ExpiredCarryForwardCaseIds.Add(CaseId);
			LongTermArchivedCaseIds.Add(CaseId);
			if (StableArchiveHits > 0 && !bRecurringCase && OpenCarryForwardHits == 0)
			{
				StableLongTermArchivedCaseIds.Add(CaseId);
			}
			else
			{
				ProvisionalArchivedCaseIds.Add(CaseId);
				if (bRecurringCase
					|| RecommendationHistory.bHasRepeatRecommendationPressure
					|| OpenCarryForwardHits > 0)
				{
					ReopenRiskArchivedCaseIds.Add(CaseId);
				}
			}
			continue;
		}

		RetainedCarryForwardCaseIds.Add(CaseId);
		if (EscalationHits > 0)
		{
			EscalationRetainedCaseIds.Add(CaseId);
		}
	}

	Summary.LongTermArchivedCaseIds = LongTermArchivedCaseIds.Array();
	Summary.ExpiredCarryForwardCaseIds = ExpiredCarryForwardCaseIds.Array();
	Summary.RetainedCarryForwardCaseIds = RetainedCarryForwardCaseIds.Array();
	Summary.EscalationRetainedCaseIds = EscalationRetainedCaseIds.Array();
	Summary.SuppressedResolvedCaseIds = SuppressedResolvedCaseIds.Array();
	Summary.StableLongTermArchivedCaseIds = StableLongTermArchivedCaseIds.Array();
	Summary.ProvisionalArchivedCaseIds = ProvisionalArchivedCaseIds.Array();
	Summary.ReopenRiskArchivedCaseIds = ReopenRiskArchivedCaseIds.Array();
	Summary.LongTermArchivedCaseIds.Sort();
	Summary.ExpiredCarryForwardCaseIds.Sort();
	Summary.RetainedCarryForwardCaseIds.Sort();
	Summary.EscalationRetainedCaseIds.Sort();
	Summary.SuppressedResolvedCaseIds.Sort();
	Summary.StableLongTermArchivedCaseIds.Sort();
	Summary.ProvisionalArchivedCaseIds.Sort();
	Summary.ReopenRiskArchivedCaseIds.Sort();

	Summary.LongTermArchivedCaseCount = Summary.LongTermArchivedCaseIds.Num();
	Summary.ExpiredCarryForwardCaseCount = Summary.ExpiredCarryForwardCaseIds.Num();
	Summary.RetainedCarryForwardCaseCount = Summary.RetainedCarryForwardCaseIds.Num();
	Summary.EscalationRetainedCaseCount = Summary.EscalationRetainedCaseIds.Num();
	Summary.SuppressedResolvedCaseCount = Summary.SuppressedResolvedCaseIds.Num();
	Summary.StableLongTermArchivedCaseCount = Summary.StableLongTermArchivedCaseIds.Num();
	Summary.ProvisionalArchivedCaseCount = Summary.ProvisionalArchivedCaseIds.Num();
	Summary.ReopenRiskArchivedCaseCount = Summary.ReopenRiskArchivedCaseIds.Num();

	Summary.bShouldExpireResolvedCarryForward = Summary.ExpiredCarryForwardCaseCount > 0;
	Summary.bShouldRetainEscalationCarryForward = Summary.EscalationRetainedCaseCount > 0;
	Summary.ArchiveStabilityScore = FMath::Clamp(
		ClosureMemory.AverageClosureScore
		+ (static_cast<float>(Summary.LongTermArchivedCaseCount) * 5.0f)
		+ (static_cast<float>(Summary.StableLongTermArchivedCaseCount) * 4.0f)
		+ (bStableClosureMemory ? 10.0f : 0.0f)
		- (static_cast<float>(Summary.ProvisionalArchivedCaseCount) * 3.0f)
		- (static_cast<float>(Summary.ReopenRiskArchivedCaseCount) * 8.0f)
		- (static_cast<float>(Summary.RetainedCarryForwardCaseCount) * 4.0f)
		- (static_cast<float>(Summary.EscalationRetainedCaseCount) * 10.0f)
		- (RecommendationHistory.bHasRepeatRecommendationPressure ? 6.0f : 0.0f),
		0.0f,
		100.0f
	);
	Summary.ArchiveRetentionTuningScore = FMath::Clamp(
		(static_cast<float>(Summary.ReopenRiskArchivedCaseCount) * 18.0f)
		+ (static_cast<float>(Summary.ProvisionalArchivedCaseCount) * 9.0f)
		+ (RecommendationHistory.bHasRepeatRecommendationPressure ? 12.0f : 0.0f)
		+ (Summary.bShouldRetainEscalationCarryForward ? 14.0f : 0.0f)
		- (static_cast<float>(Summary.StableLongTermArchivedCaseCount) * 6.0f),
		0.0f,
		100.0f
	);
	Summary.bHasStableArchiveMemory =
		Summary.LongTermArchivedCaseCount > 0
		&& Summary.ArchiveStabilityScore >= 55.0f
		&& Summary.EscalationRetainedCaseCount == 0;
	Summary.bNeedsArchiveRetentionTuning =
		Summary.ReopenRiskArchivedCaseCount > 0
		|| Summary.ArchiveRetentionTuningScore >= 25.0f
		|| (Summary.ProvisionalArchivedCaseCount > Summary.StableLongTermArchivedCaseCount
			&& Summary.LongTermArchivedCaseCount > 0);
	Summary.bHasActiveArchivePressure =
		Summary.RetainedCarryForwardCaseCount > 0
		|| Summary.EscalationRetainedCaseCount > 0
		|| Summary.bNeedsArchiveRetentionTuning;

	return Summary;
}

FHyperTwistTrainingCaseRecommendation UHyperTwistTrainingRepositoryLibrary::MakeCaseRecommendation(
	const FHyperTwistTrainingCase& TrainingCase,
	const FHyperTwistTrainingCaseLearnerState& LearnerState,
	const FString& ReferenceUtc
)
{
	return HyperTwistTrainingRepositoryLibraryInternal::MakeRecommendationInternal(
		TrainingCase,
		LearnerState,
		ReferenceUtc
	);
}

FHyperTwistTrainingReviewPolicy UHyperTwistTrainingRepositoryLibrary::GetDefaultReviewPolicy(
	EHyperTwistTrainingDeliveryMode DeliveryMode
)
{
	FHyperTwistTrainingReviewPolicy ReviewPolicy;
	ReviewPolicy.DeliveryMode = DeliveryMode;
	ReviewPolicy.MaxCases = 5;
	ReviewPolicy.NewCaseBias = 0.0f;
	ReviewPolicy.DueCaseBias = 0.0f;
	ReviewPolicy.RecognitionBias = 0.0f;
	ReviewPolicy.AccuracyBias = 0.0f;
	ReviewPolicy.bRepeatFailuresImmediately = true;
	ReviewPolicy.bPreferShortReviewSets = false;

	switch (DeliveryMode)
	{
	case EHyperTwistTrainingDeliveryMode::VirtualCube:
		ReviewPolicy.PolicyKind = EHyperTwistTrainingReviewPolicyKind::VirtualCubePractice;
		ReviewPolicy.PolicyLabel = TEXT("virtual-cube-practice");
		ReviewPolicy.MaxCases = 6;
		ReviewPolicy.NewCaseBias = 80.0f;
		ReviewPolicy.DueCaseBias = 95.0f;
		ReviewPolicy.AccuracyBias = 20.0f;
		break;

	case EHyperTwistTrainingDeliveryMode::SmartDevice:
		ReviewPolicy.PolicyKind = EHyperTwistTrainingReviewPolicyKind::SmartDeviceAccuracy;
		ReviewPolicy.PolicyLabel = TEXT("smart-device-accuracy");
		ReviewPolicy.MaxCases = 5;
		ReviewPolicy.DueCaseBias = 115.0f;
		ReviewPolicy.AccuracyBias = 90.0f;
		ReviewPolicy.bPreferShortReviewSets = true;
		break;

	case EHyperTwistTrainingDeliveryMode::RecognitionAssisted:
		ReviewPolicy.PolicyKind = EHyperTwistTrainingReviewPolicyKind::RecognitionAssistedScan;
		ReviewPolicy.PolicyLabel = TEXT("recognition-assisted-scan");
		ReviewPolicy.MaxCases = 4;
		ReviewPolicy.NewCaseBias = -20.0f;
		ReviewPolicy.DueCaseBias = 105.0f;
		ReviewPolicy.RecognitionBias = 130.0f;
		ReviewPolicy.AccuracyBias = 45.0f;
		ReviewPolicy.bPreferShortReviewSets = true;
		break;

	case EHyperTwistTrainingDeliveryMode::CoachReviewed:
		ReviewPolicy.PolicyKind = EHyperTwistTrainingReviewPolicyKind::CoachReview;
		ReviewPolicy.PolicyLabel = TEXT("coach-review");
		ReviewPolicy.MaxCases = 4;
		ReviewPolicy.NewCaseBias = 35.0f;
		ReviewPolicy.DueCaseBias = 90.0f;
		ReviewPolicy.RecognitionBias = 30.0f;
		ReviewPolicy.AccuracyBias = 110.0f;
		ReviewPolicy.bPreferShortReviewSets = true;
		break;

	case EHyperTwistTrainingDeliveryMode::Timer:
	default:
		ReviewPolicy.PolicyKind = EHyperTwistTrainingReviewPolicyKind::TimerBalanced;
		ReviewPolicy.PolicyLabel = TEXT("timer-balanced");
		ReviewPolicy.MaxCases = 5;
		ReviewPolicy.NewCaseBias = -10.0f;
		ReviewPolicy.DueCaseBias = 120.0f;
		ReviewPolicy.AccuracyBias = 35.0f;
		break;
	}

	return ReviewPolicy;
}

TArray<FHyperTwistTrainingCaseRecommendation> UHyperTwistTrainingRepositoryLibrary::ListCaseRecommendationsForDeck(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingDeck& Deck,
	const FString& UserId,
	const FString& ReferenceUtc,
	int32 MaxRecommendations
)
{
	TArray<FHyperTwistTrainingCaseRecommendation> Recommendations;
	if (!Deck.IsStructurallyValid())
	{
		return Recommendations;
	}

	for (const FHyperTwistTrainingCase& TrainingCase : Deck.Cases)
	{
		if (!TrainingCase.IsStructurallyValid())
		{
			continue;
		}

		FHyperTwistTrainingCaseLearnerState LearnerState;
		TryGetLearnerState(RepositoryState, UserId, Deck.DeckId, TrainingCase.CaseId, LearnerState);
		FHyperTwistTrainingCaseRecommendation Recommendation = MakeCaseRecommendation(
			TrainingCase,
			LearnerState,
			ReferenceUtc
		);
		if (Recommendation.IsStructurallyValid())
		{
			Recommendations.Add(Recommendation);
		}
	}

	Recommendations.Sort([](const FHyperTwistTrainingCaseRecommendation& Left, const FHyperTwistTrainingCaseRecommendation& Right)
	{
		if (!FMath::IsNearlyEqual(Left.RecommendationScore, Right.RecommendationScore))
		{
			return Left.RecommendationScore > Right.RecommendationScore;
		}

		if (!FMath::IsNearlyEqual(Left.DaysUntilDue, Right.DaysUntilDue))
		{
			return Left.DaysUntilDue < Right.DaysUntilDue;
		}

		return Left.TrainingCase.CaseId < Right.TrainingCase.CaseId;
	});

	if (MaxRecommendations > 0 && Recommendations.Num() > MaxRecommendations)
	{
		Recommendations.SetNum(MaxRecommendations, EAllowShrinking::No);
	}

	return Recommendations;
}

TArray<FHyperTwistTrainingCaseRecommendation> UHyperTwistTrainingRepositoryLibrary::ApplyReviewPolicyToRecommendations(
	const TArray<FHyperTwistTrainingCaseRecommendation>& Recommendations,
	const FHyperTwistTrainingReviewPolicy& ReviewPolicy,
	int32 MaxRecommendations
)
{
	TArray<FHyperTwistTrainingCaseRecommendation> FilteredRecommendations;
	FilteredRecommendations.Reserve(Recommendations.Num());

	for (const FHyperTwistTrainingCaseRecommendation& Recommendation : Recommendations)
	{
		if (!Recommendation.IsStructurallyValid())
		{
			continue;
		}

		FHyperTwistTrainingCaseRecommendation FilteredRecommendation = Recommendation;
		float AdjustedScore = FilteredRecommendation.RecommendationScore;

		if (FilteredRecommendation.bIsNewCase)
		{
			AdjustedScore += ReviewPolicy.NewCaseBias;
		}
		if (FilteredRecommendation.bIsDue)
		{
			AdjustedScore += ReviewPolicy.DueCaseBias;
		}
		if (FilteredRecommendation.TrainingCase.PromptKind == EHyperTwistTrainingPromptKind::Recognition
			|| ReviewPolicy.DeliveryMode == EHyperTwistTrainingDeliveryMode::RecognitionAssisted)
		{
			AdjustedScore += ReviewPolicy.RecognitionBias;
		}
		if (FilteredRecommendation.bRequiresReviewFocus
			|| FilteredRecommendation.LearnerState.LastGrade == EHyperTwistTrainingReviewGrade::Again
			|| FilteredRecommendation.LearnerState.LastGrade == EHyperTwistTrainingReviewGrade::Hard
			|| FilteredRecommendation.LearnerState.LapseCount > 0)
		{
			AdjustedScore += ReviewPolicy.AccuracyBias;
		}

		if (ReviewPolicy.bPreferShortReviewSets
			&& !FilteredRecommendation.bIsDue
			&& !FilteredRecommendation.bRequiresReviewFocus
			&& !FilteredRecommendation.bIsNewCase)
		{
			AdjustedScore -= 55.0f;
		}

		FilteredRecommendation.RecommendationScore = AdjustedScore;
		FilteredRecommendations.Add(FilteredRecommendation);
	}

	FilteredRecommendations.Sort([](const FHyperTwistTrainingCaseRecommendation& Left, const FHyperTwistTrainingCaseRecommendation& Right)
	{
		if (!FMath::IsNearlyEqual(Left.RecommendationScore, Right.RecommendationScore))
		{
			return Left.RecommendationScore > Right.RecommendationScore;
		}

		if (!FMath::IsNearlyEqual(Left.DaysUntilDue, Right.DaysUntilDue))
		{
			return Left.DaysUntilDue < Right.DaysUntilDue;
		}

		return Left.TrainingCase.CaseId < Right.TrainingCase.CaseId;
	});

	const int32 EffectiveMaxRecommendations = HyperTwistTrainingRepositoryLibraryInternal::ResolvePolicyCaseLimit(
		ReviewPolicy,
		MaxRecommendations
	);
	if (EffectiveMaxRecommendations > 0 && FilteredRecommendations.Num() > EffectiveMaxRecommendations)
	{
		FilteredRecommendations.SetNum(EffectiveMaxRecommendations, EAllowShrinking::No);
	}

	return FilteredRecommendations;
}

FHyperTwistTrainingDeck UHyperTwistTrainingRepositoryLibrary::BuildReviewDeckFromRecommendations(
	const FHyperTwistTrainingDeck& SourceDeck,
	const TArray<FHyperTwistTrainingCaseRecommendation>& Recommendations,
	int32 MaxCases
)
{
	FHyperTwistTrainingDeck ReviewDeck = SourceDeck;
	if (!SourceDeck.IsStructurallyValid())
	{
		return FHyperTwistTrainingDeck();
	}

	ReviewDeck.DeckId = SourceDeck.DeckId + TEXT("/review");
	ReviewDeck.Title = SourceDeck.Title + TEXT(" Review");
	ReviewDeck.SelectionPolicy = EHyperTwistTrainingSelectionPolicy::Spaced;
	ReviewDeck.Tags = SourceDeck.Tags;
	ReviewDeck.Tags.AddUnique(TEXT("review"));
	ReviewDeck.Tags.AddUnique(TEXT("recommendation-shaped"));
	ReviewDeck.Cases.Reset();

	const int32 EffectiveMaxCases = MaxCases > 0 ? MaxCases : Recommendations.Num();
	for (const FHyperTwistTrainingCaseRecommendation& Recommendation : Recommendations)
	{
		if (!Recommendation.IsStructurallyValid())
		{
			continue;
		}

		ReviewDeck.Cases.Add(Recommendation.TrainingCase);
		if (ReviewDeck.Cases.Num() >= EffectiveMaxCases)
		{
			break;
		}
	}

	if (ReviewDeck.Cases.Num() == 0)
	{
		return FHyperTwistTrainingDeck();
	}

	return ReviewDeck;
}

FHyperTwistTrainingReviewPlanState UHyperTwistTrainingRepositoryLibrary::BuildReviewPlan(
	const FHyperTwistTrainingDeck& SourceDeck,
	const FHyperTwistTrainingDeck& ReviewDeck,
	const FString& UserId,
	const TArray<FHyperTwistTrainingCaseRecommendation>& Recommendations,
	const FHyperTwistTrainingReviewPolicy& ReviewPolicy,
	const FString& PlanId,
	const FString& ReferenceUtc,
	EHyperTwistTrainingDeliveryMode DeliveryMode
)
{
	FHyperTwistTrainingReviewPlanState ReviewPlan;
	if (!SourceDeck.IsStructurallyValid() || !ReviewDeck.IsStructurallyValid() || UserId.IsEmpty())
	{
		return ReviewPlan;
	}

	ReviewPlan.PlanId = PlanId.IsEmpty() ? FString::Printf(TEXT("review_plan_%s"), *ReviewDeck.DeckId) : PlanId;
	ReviewPlan.UserId = UserId;
	ReviewPlan.SourceDeckId = SourceDeck.DeckId;
	ReviewPlan.ReviewDeckId = ReviewDeck.DeckId;
	ReviewPlan.ReferenceUtc = ReferenceUtc.IsEmpty() ? FDateTime::UtcNow().ToIso8601() : ReferenceUtc;
	ReviewPlan.DeliveryMode = DeliveryMode;
	ReviewPlan.Policy = ReviewPolicy;
	ReviewPlan.CreatedAtUtc = ReviewPlan.ReferenceUtc;
	ReviewPlan.StartedAtUtc = ReviewPlan.ReferenceUtc;

	for (const FHyperTwistTrainingCase& TrainingCase : ReviewDeck.Cases)
	{
		if (!TrainingCase.IsStructurallyValid())
		{
			continue;
		}

		const FHyperTwistTrainingCaseRecommendation* MatchingRecommendation = Recommendations.FindByPredicate(
			[&TrainingCase](const FHyperTwistTrainingCaseRecommendation& Candidate)
			{
				return Candidate.TrainingCase.CaseId == TrainingCase.CaseId;
			}
		);

		FHyperTwistTrainingReviewPlanEntry Entry;
		Entry.CaseId = TrainingCase.CaseId;
		Entry.PromptLabel = TrainingCase.PromptLabel;
		Entry.RecommendationReason = MatchingRecommendation != nullptr ? MatchingRecommendation->RecommendationReason : TEXT("review-case");
		Entry.RecommendationScore = MatchingRecommendation != nullptr ? MatchingRecommendation->RecommendationScore : 0.0f;
		Entry.EntryState = EHyperTwistTrainingReviewPlanEntryState::Pending;
		ReviewPlan.Entries.Add(Entry);
	}

	if (ReviewPlan.Entries.Num() > 0)
	{
		ReviewPlan.CurrentEntryIndex = 0;
		ReviewPlan.Entries[0].EntryState = EHyperTwistTrainingReviewPlanEntryState::Current;
	}

	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(ReviewPlan);
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRepositoryLibrary::UpsertReviewPlan(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FHyperTwistTrainingReviewPlanState& ReviewPlan
)
{
	FHyperTwistTrainingRepositoryState UpdatedState = RepositoryState;
	const FHyperTwistTrainingReviewPlanState NormalizedReviewPlan =
		HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(ReviewPlan);
	if (!NormalizedReviewPlan.IsStructurallyValid())
	{
		return UpdatedState;
	}

	const int32 ExistingIndex = UpdatedState.ReviewPlans.IndexOfByPredicate(
		[&NormalizedReviewPlan](const FHyperTwistTrainingReviewPlanState& ExistingPlan)
		{
			return ExistingPlan.PlanId == NormalizedReviewPlan.PlanId;
		}
	);

	if (ExistingIndex >= 0)
	{
		UpdatedState.ReviewPlans[ExistingIndex] = NormalizedReviewPlan;
	}
	else
	{
		UpdatedState.ReviewPlans.Add(NormalizedReviewPlan);
	}

	return UpdatedState;
}

bool UHyperTwistTrainingRepositoryLibrary::TryGetReviewPlan(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& PlanId,
	FHyperTwistTrainingReviewPlanState& OutReviewPlan
)
{
	OutReviewPlan = FHyperTwistTrainingReviewPlanState();
	if (PlanId.IsEmpty())
	{
		return false;
	}

	const FHyperTwistTrainingReviewPlanState* ExistingPlan = RepositoryState.ReviewPlans.FindByPredicate(
		[&PlanId](const FHyperTwistTrainingReviewPlanState& Candidate)
		{
			return Candidate.PlanId == PlanId;
		}
	);

	if (ExistingPlan == nullptr)
	{
		return false;
	}

	OutReviewPlan = HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(*ExistingPlan);
	return OutReviewPlan.IsStructurallyValid();
}

FHyperTwistTrainingReviewPlanState UHyperTwistTrainingRepositoryLibrary::UpdateReviewPlanAfterAttempt(
	const FHyperTwistTrainingReviewPlanState& ReviewPlan,
	const FHyperTwistTrainingRunStepResult& StepResult,
	const FHyperTwistTrainingAttempt& Attempt
)
{
	FHyperTwistTrainingReviewPlanState UpdatedPlan = ReviewPlan;
	if (!UpdatedPlan.IsStructurallyValid() || !StepResult.IsStructurallyValid() || !Attempt.IsStructurallyValid())
	{
		return UpdatedPlan;
	}

	const int32 EntryIndex = UpdatedPlan.Entries.IndexOfByPredicate(
		[&Attempt](const FHyperTwistTrainingReviewPlanEntry& Entry)
		{
			return Entry.CaseId == Attempt.CaseId;
		}
	);
	if (EntryIndex < 0)
	{
		return UpdatedPlan;
	}

	FHyperTwistTrainingReviewPlanEntry& Entry = UpdatedPlan.Entries[EntryIndex];
	Entry.AttemptCount += 1;
	Entry.LastAttemptId = Attempt.AttemptId;
	Entry.LastOutcome = Attempt.Result;
	Entry.LastCompletedAtUtc = Attempt.CompletedAtUtc;

	if (Attempt.Result == EHyperTwistTrainingAttemptResult::Success)
	{
		Entry.SuccessCount += 1;
		Entry.EntryState = EHyperTwistTrainingReviewPlanEntryState::Completed;
	}
	else if (Attempt.Result == EHyperTwistTrainingAttemptResult::Aborted)
	{
		Entry.EntryState = EHyperTwistTrainingReviewPlanEntryState::Skipped;
	}
	else
	{
		Entry.EntryState = EHyperTwistTrainingReviewPlanEntryState::NeedsRepeat;
	}

	for (int32 Index = 0; Index < UpdatedPlan.Entries.Num(); ++Index)
	{
		if (Index == EntryIndex)
		{
			continue;
		}

		if (UpdatedPlan.Entries[Index].EntryState == EHyperTwistTrainingReviewPlanEntryState::Current)
		{
			UpdatedPlan.Entries[Index].EntryState = EHyperTwistTrainingReviewPlanEntryState::Pending;
		}
	}

	const EHyperTwistTrainingSessionState SessionState = StepResult.UpdatedRunState.Session.SessionState;
	if (SessionState == EHyperTwistTrainingSessionState::Completed
		|| SessionState == EHyperTwistTrainingSessionState::Aborted)
	{
		UpdatedPlan.bCompleted = true;
		UpdatedPlan.CurrentEntryIndex = INDEX_NONE;
		UpdatedPlan.CompletedAtUtc = !StepResult.UpdatedRunState.Session.EndedAtUtc.IsEmpty()
			? StepResult.UpdatedRunState.Session.EndedAtUtc
			: Attempt.CompletedAtUtc;
		return HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(UpdatedPlan);
	}

	FString NextCaseId;
	if (StepResult.UpdatedRunState.CurrentSelection.IsStructurallyValid())
	{
		NextCaseId = StepResult.UpdatedRunState.CurrentSelection.TrainingCase.CaseId;
	}
	if (NextCaseId.IsEmpty())
	{
		NextCaseId = StepResult.UpdatedRunState.Session.CurrentCaseId;
	}

	int32 NextEntryIndex = INDEX_NONE;
	if (!NextCaseId.IsEmpty())
	{
		NextEntryIndex = UpdatedPlan.Entries.IndexOfByPredicate(
			[&NextCaseId](const FHyperTwistTrainingReviewPlanEntry& Candidate)
			{
				return Candidate.CaseId == NextCaseId
					&& Candidate.EntryState != EHyperTwistTrainingReviewPlanEntryState::Completed
					&& Candidate.EntryState != EHyperTwistTrainingReviewPlanEntryState::Skipped;
			}
		);
	}

	if (NextEntryIndex < 0)
	{
		NextEntryIndex = UpdatedPlan.Entries.IndexOfByPredicate(
			[](const FHyperTwistTrainingReviewPlanEntry& Candidate)
			{
				return Candidate.EntryState == EHyperTwistTrainingReviewPlanEntryState::NeedsRepeat
					|| Candidate.EntryState == EHyperTwistTrainingReviewPlanEntryState::Pending;
			}
		);
	}

	UpdatedPlan.CurrentEntryIndex = NextEntryIndex;
	if (NextEntryIndex >= 0)
	{
		UpdatedPlan.Entries[NextEntryIndex].EntryState = EHyperTwistTrainingReviewPlanEntryState::Current;
	}

	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(UpdatedPlan);
}

FHyperTwistTrainingReviewFlowStatus UHyperTwistTrainingRepositoryLibrary::DeriveReviewFlowStatus(
	const FHyperTwistTrainingReviewPlanState& ReviewPlan
)
{
	FHyperTwistTrainingReviewFlowStatus FlowStatus;
	if (!ReviewPlan.IsStructurallyValid())
	{
		return FlowStatus;
	}

	FlowStatus.PlanId = ReviewPlan.PlanId;
	FlowStatus.bPlanComplete = ReviewPlan.bCompleted;

	int32 CurrentEntryIndex = ReviewPlan.CurrentEntryIndex;
	if (!ReviewPlan.Entries.IsValidIndex(CurrentEntryIndex))
	{
		CurrentEntryIndex = ReviewPlan.Entries.IndexOfByPredicate(
			[](const FHyperTwistTrainingReviewPlanEntry& Entry)
			{
				return Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::Current;
			}
		);
	}

	for (const FHyperTwistTrainingReviewPlanEntry& Entry : ReviewPlan.Entries)
	{
		switch (Entry.EntryState)
		{
		case EHyperTwistTrainingReviewPlanEntryState::Pending:
			FlowStatus.PendingCount += 1;
			break;
		case EHyperTwistTrainingReviewPlanEntryState::NeedsRepeat:
			FlowStatus.RepeatCount += 1;
			break;
		case EHyperTwistTrainingReviewPlanEntryState::Completed:
			FlowStatus.CompletedCount += 1;
			break;
		case EHyperTwistTrainingReviewPlanEntryState::Skipped:
			FlowStatus.SkippedCount += 1;
			break;
		default:
			break;
		}

		if (Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::NeedsRepeat && Entry.AttemptCount >= 2)
		{
			FlowStatus.bNeedsCoachIntervention = true;
		}
	}

	const bool bCoachFacingRepeatPressure =
		FlowStatus.RepeatCount > 0
		&& (
			ReviewPlan.Policy.PolicyKind == EHyperTwistTrainingReviewPolicyKind::CoachReview
			|| ReviewPlan.Policy.bPreferRecognitionReplayReview
		);
	if (bCoachFacingRepeatPressure)
	{
		FlowStatus.bNeedsCoachIntervention = true;
	}

	const int32 TotalTerminalCount = FlowStatus.CompletedCount + FlowStatus.SkippedCount;
	if (ReviewPlan.Entries.Num() > 0)
	{
		FlowStatus.ProgressRatio = static_cast<float>(TotalTerminalCount) / static_cast<float>(ReviewPlan.Entries.Num());
	}

	if (ReviewPlan.Entries.IsValidIndex(CurrentEntryIndex))
	{
		const FHyperTwistTrainingReviewPlanEntry& CurrentEntry = ReviewPlan.Entries[CurrentEntryIndex];
		FlowStatus.CurrentCaseId = CurrentEntry.CaseId;
		FlowStatus.CurrentPromptLabel = CurrentEntry.PromptLabel;
		FlowStatus.bHasCurrentEntry = true;
	}

	if (FlowStatus.bPlanComplete || TotalTerminalCount >= ReviewPlan.Entries.Num())
	{
		FlowStatus.bPlanComplete = true;
		FlowStatus.NextActionLabel = TEXT("review-complete");
	}
	else if (FlowStatus.bNeedsCoachIntervention)
	{
		FlowStatus.NextActionLabel = TEXT("coach-review-needed");
	}
	else if (FlowStatus.bHasCurrentEntry)
	{
		FlowStatus.NextActionLabel = TEXT("continue-review");
	}
	else if (FlowStatus.RepeatCount > 0)
	{
		FlowStatus.NextActionLabel = TEXT("repeat-failed-cases");
	}
	else if (FlowStatus.PendingCount > 0)
	{
		FlowStatus.NextActionLabel = TEXT("advance-to-next-case");
	}
	else
	{
		FlowStatus.NextActionLabel = TEXT("finalize-review");
	}

	return FlowStatus;
}

FHyperTwistTrainingReviewProgramSummary UHyperTwistTrainingRepositoryLibrary::DeriveReviewProgramSummary(
	const FHyperTwistTrainingRepositoryState& RepositoryState,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	FHyperTwistTrainingReviewProgramSummary Summary;
	if (UserId.IsEmpty())
	{
		return Summary;
	}

	Summary.UserId = UserId;
	Summary.ReferenceUtc = HyperTwistTrainingRepositoryLibraryInternal::ResolveReferenceUtc(ReferenceUtc);

	const TArray<FHyperTwistTrainingMethodSegment> MethodSegments = DeriveLearnerMethodSegments(
		RepositoryState,
		UserId,
		Summary.ReferenceUtc
	);
	const auto ResolveMethodSegmentIdForDeck = [&MethodSegments](const FString& DeckId) -> FString
	{
		for (const FHyperTwistTrainingMethodSegment& MethodSegment : MethodSegments)
		{
			if (MethodSegment.DeckIds.Contains(DeckId))
			{
				return MethodSegment.MethodDescriptor.SegmentId;
			}
		}

		return FString();
	};

	int32 BestCarryoverScore = -1;
	FString BestPlanCreatedAtUtc;
	FString LatestCompletedAtUtc;
	int32 DeliveryModeCounts[5] = {0, 0, 0, 0, 0};
	TMap<EHyperTwistTrainingReviewPolicyKind, int32> PolicyCounts;
	int64 CompletedPlanDurationAccumulator = 0;
	int32 CompletedPlanDurationCount = 0;
	float ProgressRatioAccumulator = 0.0f;

	for (const FHyperTwistTrainingReviewPlanState& ReviewPlan : RepositoryState.ReviewPlans)
	{
		if (!ReviewPlan.IsStructurallyValid() || ReviewPlan.UserId != UserId)
		{
			continue;
		}

		const FHyperTwistTrainingReviewFlowStatus FlowStatus = DeriveReviewFlowStatus(ReviewPlan);
		const int32 CarryoverCount = FlowStatus.PendingCount
			+ FlowStatus.RepeatCount
			+ (FlowStatus.bHasCurrentEntry ? 1 : 0);
		const int32 DeliveryModeIndex = FMath::Clamp(static_cast<int32>(ReviewPlan.DeliveryMode), 0, 4);
		DeliveryModeCounts[DeliveryModeIndex] += 1;
		PolicyCounts.FindOrAdd(ReviewPlan.Policy.PolicyKind) += 1;
		Summary.TotalPlanCount += 1;
		Summary.TotalEntryCount += ReviewPlan.Entries.Num();
		Summary.CompletedEntryCount += FlowStatus.CompletedCount;
		Summary.SkippedEntryCount += FlowStatus.SkippedCount;
		ProgressRatioAccumulator += FlowStatus.ProgressRatio;

		if (Summary.LastPlanCreatedAtUtc.IsEmpty()
			|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(
				ReviewPlan.CreatedAtUtc,
				Summary.LastPlanCreatedAtUtc
			) > 0)
		{
			Summary.LastPlanCreatedAtUtc = ReviewPlan.CreatedAtUtc;
		}

		if (ReviewPlan.bCompleted || FlowStatus.bPlanComplete)
		{
			Summary.CompletedPlanCount += 1;
			const FString CompletedAtUtc = !ReviewPlan.CompletedAtUtc.IsEmpty()
				? ReviewPlan.CompletedAtUtc
				: ReviewPlan.CreatedAtUtc;
			if (LatestCompletedAtUtc.IsEmpty()
				|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(CompletedAtUtc, LatestCompletedAtUtc) > 0)
			{
				LatestCompletedAtUtc = CompletedAtUtc;
				Summary.LastCompletedPlanId = ReviewPlan.PlanId;
			}
			const int32 PlanDurationMs = HyperTwistTrainingRepositoryLibraryInternal::ComputePlanDurationMs(
				ReviewPlan,
				Summary.ReferenceUtc
			);
			if (PlanDurationMs > 0)
			{
				CompletedPlanDurationAccumulator += PlanDurationMs;
				CompletedPlanDurationCount += 1;
				if (Summary.BestCompletedPlanDurationMs == 0 || PlanDurationMs < Summary.BestCompletedPlanDurationMs)
				{
					Summary.BestCompletedPlanDurationMs = PlanDurationMs;
				}
			}
			continue;
		}

		Summary.PendingPlanIds.Add(ReviewPlan.PlanId);
		Summary.PendingPlanCount += 1;
		Summary.PendingEntryCount += FlowStatus.PendingCount;
		Summary.RepeatEntryCount += FlowStatus.RepeatCount;
		Summary.CarryoverCaseCount += CarryoverCount;
		if (FlowStatus.bNeedsCoachIntervention)
		{
			Summary.CoachInterventionPlanCount += 1;
			Summary.bNeedsCoachIntervention = true;
		}

		const int32 CarryoverScore = CarryoverCount * 100
			+ (FlowStatus.bNeedsCoachIntervention ? 25 : 0)
			+ (FlowStatus.bHasCurrentEntry ? 10 : 0);
		if (CarryoverScore > BestCarryoverScore
			|| (CarryoverScore == BestCarryoverScore
				&& (BestPlanCreatedAtUtc.IsEmpty()
					|| HyperTwistTrainingRepositoryLibraryInternal::CompareUtcStrings(ReviewPlan.CreatedAtUtc, BestPlanCreatedAtUtc) > 0)))
		{
			BestCarryoverScore = CarryoverScore;
			BestPlanCreatedAtUtc = ReviewPlan.CreatedAtUtc;
			Summary.FocusDeckId = ReviewPlan.SourceDeckId;
			Summary.FocusMethodSegmentId = ResolveMethodSegmentIdForDeck(ReviewPlan.SourceDeckId);
			Summary.NextPlanId = ReviewPlan.PlanId;
			if (FlowStatus.bHasCurrentEntry)
			{
				Summary.CurrentPlanId = ReviewPlan.PlanId;
			}
		}

		if (Summary.CurrentPlanId.IsEmpty() && FlowStatus.bHasCurrentEntry)
		{
			Summary.CurrentPlanId = ReviewPlan.PlanId;
		}
	}

	if (Summary.CurrentPlanId.IsEmpty())
	{
		Summary.CurrentPlanId = Summary.NextPlanId;
	}
	if (Summary.FocusMethodSegmentId.IsEmpty() && !Summary.FocusDeckId.IsEmpty())
	{
		Summary.FocusMethodSegmentId = ResolveMethodSegmentIdForDeck(Summary.FocusDeckId);
	}

	if (Summary.TotalPlanCount > 0)
	{
		Summary.AveragePlanProgressRatio = ProgressRatioAccumulator / static_cast<float>(Summary.TotalPlanCount);
	}
	if (Summary.PendingPlanCount > 0)
	{
		Summary.AveragePendingEntriesPerOpenPlan =
			static_cast<float>(Summary.PendingEntryCount) / static_cast<float>(Summary.PendingPlanCount);
		Summary.AverageCarryoverCasesPerOpenPlan =
			static_cast<float>(Summary.CarryoverCaseCount) / static_cast<float>(Summary.PendingPlanCount);
	}
	if (CompletedPlanDurationCount > 0)
	{
		Summary.AverageCompletedPlanDurationMs = static_cast<int32>(
			CompletedPlanDurationAccumulator / CompletedPlanDurationCount
		);
	}

	int32 BestModeCount = -1;
	for (int32 ModeIndex = 0; ModeIndex < UE_ARRAY_COUNT(DeliveryModeCounts); ++ModeIndex)
	{
		if (DeliveryModeCounts[ModeIndex] > BestModeCount)
		{
			BestModeCount = DeliveryModeCounts[ModeIndex];
			Summary.DominantDeliveryMode = static_cast<EHyperTwistTrainingDeliveryMode>(ModeIndex);
		}
	}

	int32 BestPolicyCount = -1;
	for (const TPair<EHyperTwistTrainingReviewPolicyKind, int32>& Pair : PolicyCounts)
	{
		if (Pair.Value > BestPolicyCount)
		{
			BestPolicyCount = Pair.Value;
			Summary.DominantPolicyKind = Pair.Key;
		}
	}

	Summary.ProgramPressureScore =
		static_cast<float>(Summary.CarryoverCaseCount * 1.0f)
		+ static_cast<float>(Summary.RepeatEntryCount * 1.5f)
		+ static_cast<float>(Summary.CoachInterventionPlanCount * 3.0f)
		+ (Summary.CurrentPlanId.IsEmpty() ? 0.0f : 1.0f);
	Summary.bHasCarryover = Summary.CarryoverCaseCount > 0 || Summary.PendingPlanCount > 0;
	return Summary;
}

FHyperTwistTrainingReviewPlanState UHyperTwistTrainingRepositoryLibrary::FinalizeReviewPlan(
	const FHyperTwistTrainingReviewPlanState& ReviewPlan,
	const FHyperTwistTrainingSession& Session
)
{
	FHyperTwistTrainingReviewPlanState UpdatedPlan = ReviewPlan;
	if (!UpdatedPlan.IsStructurallyValid())
	{
		return UpdatedPlan;
	}

	UpdatedPlan.bCompleted = false;
	UpdatedPlan.CurrentEntryIndex = INDEX_NONE;
	UpdatedPlan.CompletedAtUtc = !Session.EndedAtUtc.IsEmpty()
		? Session.EndedAtUtc
		: FDateTime::UtcNow().ToIso8601();

	for (FHyperTwistTrainingReviewPlanEntry& Entry : UpdatedPlan.Entries)
	{
		if (Entry.EntryState == EHyperTwistTrainingReviewPlanEntryState::Current)
		{
			Entry.EntryState = Session.SessionState == EHyperTwistTrainingSessionState::Aborted
				? EHyperTwistTrainingReviewPlanEntryState::Skipped
				: EHyperTwistTrainingReviewPlanEntryState::Pending;
		}
	}

	return HyperTwistTrainingRepositoryLibraryInternal::NormalizeReviewPlanState(UpdatedPlan);
}
