#include "HyperTwistTraining/HyperTwistTrainingValidationBenchmarkLibrary.h"

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationMozzettaStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationMozzettaStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationMozzettaStateLedgerContract& Contract : Bundle.ValidationMozzettaStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationMozzettaStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateRochetBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateRochetBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateRochetBoundary& Boundary : Bundle.ValidationOngoingStateRochetBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateRochetBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationSurpliceStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationSurpliceStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationSurpliceStateLedgerContract& Contract : Bundle.ValidationSurpliceStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationSurpliceStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateTippetBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateTippetBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateTippetBoundary& Boundary : Bundle.ValidationOngoingStateTippetBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateTippetBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationChimereStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationChimereStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationChimereStateLedgerContract& Contract : Bundle.ValidationChimereStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationChimereStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateScarfBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateScarfBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateScarfBoundary& Boundary : Bundle.ValidationOngoingStateScarfBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateScarfBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationCassockStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationCassockStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationCassockStateLedgerContract& Contract : Bundle.ValidationCassockStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationCassockStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateRabatBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateRabatBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateRabatBoundary& Boundary : Bundle.ValidationOngoingStateRabatBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateRabatBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationCamauroStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationCamauroStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationCamauroStateLedgerContract& Contract : Bundle.ValidationCamauroStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationCamauroStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateSaturnoBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateSaturnoBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateSaturnoBoundary& Boundary : Bundle.ValidationOngoingStateSaturnoBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateSaturnoBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationFerraioloStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationFerraioloStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationFerraioloStateLedgerContract& Contract : Bundle.ValidationFerraioloStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationFerraioloStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateMantellettaBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateMantellettaBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateMantellettaBoundary& Boundary : Bundle.ValidationOngoingStateMantellettaBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateMantellettaBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationCappaMagnaStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationCappaMagnaStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationCappaMagnaStateLedgerContract& Contract : Bundle.ValidationCappaMagnaStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationCappaMagnaStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStatePellegrinaBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStatePellegrinaBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStatePellegrinaBoundary& Boundary : Bundle.ValidationOngoingStatePellegrinaBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStatePellegrinaBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationGaleroStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationGaleroStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationGaleroStateLedgerContract& Contract : Bundle.ValidationGaleroStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationGaleroStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateSimarBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateSimarBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateSimarBoundary& Boundary : Bundle.ValidationOngoingStateSimarBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateSimarBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationTabarroStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationTabarroStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationTabarroStateLedgerContract& Contract : Bundle.ValidationTabarroStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationTabarroStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateGremialeBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateGremialeBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateGremialeBoundary& Boundary : Bundle.ValidationOngoingStateGremialeBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateGremialeBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationFaldaStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationFaldaStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationFaldaStateLedgerContract& Contract : Bundle.ValidationFaldaStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationFaldaStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateMantumBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateMantumBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateMantumBoundary& Boundary : Bundle.ValidationOngoingStateMantumBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateMantumBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationSakkosStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationSakkosStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationSakkosStateLedgerContract& Contract : Bundle.ValidationSakkosStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationSakkosStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateOmophorionBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateOmophorionBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateOmophorionBoundary& Boundary : Bundle.ValidationOngoingStateOmophorionBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateOmophorionBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationEpigonationStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationEpigonationStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationEpigonationStateLedgerContract& Contract : Bundle.ValidationEpigonationStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationEpigonationStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateEpimanikiaBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateEpimanikiaBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateEpimanikiaBoundary& Boundary : Bundle.ValidationOngoingStateEpimanikiaBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateEpimanikiaBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOrarionStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationOrarionStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationOrarionStateLedgerContract& Contract : Bundle.ValidationOrarionStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationOrarionStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateEpitrachelionBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateEpitrachelionBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateEpitrachelionBoundary& Boundary : Bundle.ValidationOngoingStateEpitrachelionBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateEpitrachelionBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationSticharionStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationSticharionStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationSticharionStateLedgerContract& Contract : Bundle.ValidationSticharionStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationSticharionStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateZonarionBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateZonarionBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateZonarionBoundary& Boundary : Bundle.ValidationOngoingStateZonarionBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateZonarionBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationPhelonionStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationPhelonionStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationPhelonionStateLedgerContract& Contract : Bundle.ValidationPhelonionStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationPhelonionStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateRiassaBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateRiassaBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateRiassaBoundary& Boundary : Bundle.ValidationOngoingStateRiassaBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateRiassaBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationKlobukStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationKlobukStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationKlobukStateLedgerContract& Contract : Bundle.ValidationKlobukStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationKlobukStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateMandyasBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateMandyasBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateMandyasBoundary& Boundary : Bundle.ValidationOngoingStateMandyasBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateMandyasBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationKamelavkionStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationKamelavkionStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationKamelavkionStateLedgerContract& Contract : Bundle.ValidationKamelavkionStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationKamelavkionStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateEpanokamelavkionBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateEpanokamelavkionBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateEpanokamelavkionBoundary& Boundary : Bundle.ValidationOngoingStateEpanokamelavkionBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateEpanokamelavkionBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationKoukoulionStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationKoukoulionStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationKoukoulionStateLedgerContract& Contract : Bundle.ValidationKoukoulionStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationKoukoulionStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStateParamandyasBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStateParamandyasBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStateParamandyasBoundary& Boundary : Bundle.ValidationOngoingStateParamandyasBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStateParamandyasBoundary();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationAnalavosStateLedgerContractById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingValidationAnalavosStateLedgerContract& OutContract
)
{
	for (const FHyperTwistTrainingValidationAnalavosStateLedgerContract& Contract : Bundle.ValidationAnalavosStateLedgerContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingValidationAnalavosStateLedgerContract();
	return false;
}

bool UHyperTwistTrainingValidationBenchmarkLibrary::TryGetValidationOngoingStatePolystavrionBoundaryById(
	const FHyperTwistTrainingValidationBenchmarkReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingValidationOngoingStatePolystavrionBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingValidationOngoingStatePolystavrionBoundary& Boundary : Bundle.ValidationOngoingStatePolystavrionBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingValidationOngoingStatePolystavrionBoundary();
	return false;
}

