static FAutoConsoleCommand CVar_LoadPackageAsyncCommand(
	TEXT("LoadPackageAsync"),
	TEXT("Loads packages async by names. Usage: LoadPackageAsync <package name> [<package name> ...]"),
	FConsoleCommandWithArgsDelegate::CreateStatic(LoadPackageAsyncCommand));
#endif

const FName PrestreamPackageClassNameLoad = FName("PrestreamPackage");

file
function     void FConcertClientSequencePreloader::OnPreloadEvent

				UE_LOGFMT(LogConcertSequencerSync, Verbose, "OnPreloadEvent: Initiating async package load for {Path}", SequenceObjectPath.ToString());
				PreloadPendingSequences.Add(SequenceObjectPath, SoftSequenceObject);
				LoadPackageAsync(SoftSequenceObject.GetLongPackageName(), FLoadPackageAsyncDelegate::CreateLambda(
					[WeakThis = AsWeak(),
					WeakRequestSession = WeakSession,
					SequenceObjectPath,
					SoftSequenceObject]
					(const FName& PackageName, UPackage* LoadedPackage, EAsyncLoadingResult::Type Result)
					{

file
function     ULevelVariantSets* ALevelVariantSetsActor::GetLevelVariantSets

			if (IsAsyncLoading())
			{
				LoadPackageAsync(LevelVariantSets.GetLongPackageName());
				return nullptr;
			}
			else
			{
				return Cast<ULevelVariantSets>(LevelVariantSets.TryLoad());
			}

file
function     EMotionDesignAssetType FAvaSoftAssetPtr::GetAssetType

	{
		// Todo: problem with loading the asset sync here.
		// Todo: Investigate LoadPackageAsync.
		// This will cause a hitch. For level asset, we want to avoid that.
		UObject* LoadedSourceAsset;
		{
			TRACE_CPUPROFILER_EVENT_SCOPE(FAvaSoftAssetPtr::LoadSourceAsset);
			const FSoftObjectPtr SourceAsset(AssetPtr.ToSoftObjectPath());
			LoadedSourceAsset = SourceAsset.LoadSynchronous();

file
function     UAvaPlaybackGraph* FAvaPlaybackManager::LoadPlaybackObject

		}

		// Todo: Investigate LoadPackageAsync.
		// For now, we tolerate a sync load here because there will be hitch from converting the
		// Motion Design Asset to a world.
		TempPackage = LoadPackage(nullptr, *PackageName, LOAD_None );
	}
	
	if (TempPackage)

file
function     void ATemplateSequenceActor::InitializePlayer

		else
		{
			LoadPackageAsync(TemplateSequence.GetLongPackageName(), FLoadPackageAsyncDelegate::CreateUObject(this, &ATemplateSequenceActor::OnSequenceLoaded));
		}
	}
}

void ATemplateSequenceActor::OnSequenceLoaded(const FName& PackageName, UPackage* Package, EAsyncLoadingResult::Type Result)
{

file
function     void UGameFeatureAction_AddCheats::OnCheatManagerCreated

				TWeakObjectPtr<UGameFeatureAction_AddCheats> WeakThis(this);
				TWeakObjectPtr<UCheatManager> WeakCheatManager(CheatManager);
				LoadPackageAsync(CheatManagerClassPtr.GetLongPackageName(), FLoadPackageAsyncDelegate::CreateLambda(
					[WeakThis, WeakCheatManager, CheatManagerClassPtr](const FName& PackageName, UPackage* Package, EAsyncLoadingResult::Type Result)
				{
					if (Result == EAsyncLoadingResult::Succeeded)
					{
						UGameFeatureAction_AddCheats* StrongThis = WeakThis.Get();
						UCheatManager* StrongCheatManager = WeakCheatManager.Get();

file
namespace    Metasound
namespace    Editor
class        class FModule : public IMetasoundEditorModule
function     void LoadAndRegisterAsset

						}
					};
					LoadPackageAsync(AssetPath.GetLongPackageName(), FLoadPackageAsyncDelegate::CreateLambda(LoadAndRegister));
				}
			}

			void AddClassRegistryAsset(const FAssetData& InAssetData)
			{
				using namespace Frontend;

file
function     void USoundNodeModPlayer::LoadAsset

			{
				bAsyncLoading = true;
				LoadPackageAsync(LongPackageName, FLoadPackageAsyncDelegate::CreateUObject(this, &USoundNodeModPlayer::OnSoundModLoaded, bAddToRoot));
			}
		}
		else if (bAddToRoot)
		{
			SoundMod->AddToRoot();
		}

file
namespace    UE::Cook
function     bool FPackageData::TryPreload

			PackageDatas.GetMonitor().OnPreloadAllocatedChanged(*this, true);
			AsyncRequest = MakeShared<FAsyncRequest>();
			AsyncRequest->RequestID = LoadPackageAsync(
				GetFileName().ToString(), 
				FLoadPackageAsyncDelegate::CreateLambda(
					[AsyncRequest = AsyncRequest](const FName&, UPackage*, EAsyncLoadingResult::Type) { AsyncRequest->bHasFinished = true; }
				),
				32 /* Use arbitrary higher priority for preload as we're going to need them very soon */
			);

	static CORE_API TMulticastDelegate<void(const FString&)> OnAsyncLoadPackage;

	// Thread-safe callback that is called on the same thread that LoadPackageAsync is issued from.
	static CORE_API TTSMulticastDelegate<void(FStringView)>& GetOnAsyncLoadPackage();

	static CORE_API TMulticastDelegate<void(const FString&)> OnSyncLoadPackage;

	// get a hotfix delegate
	static CORE_API TDelegate<void(void*, int32)>& GetHotfixDelegate(EHotfixDelegates::Type HotFix);

file
function     static void LoadPackageAsyncCommand

	{
		UE_LOG(LogStreaming, Display, TEXT("LoadPackageAsyncCommand: %s - Requested"), *PackageName);
		LoadPackageAsync(PackageName, FLoadPackageAsyncDelegate::CreateLambda(
			[](const FName& PackageName, UPackage* Package, EAsyncLoadingResult::Type Result)
		{
			UE_LOG(LogStreaming, Display, TEXT("LoadPackageAsyncCommand: %s - %s"),
				*PackageName.ToString(), (Package != nullptr) ? TEXT("Loaded") : TEXT("Failed"));
		}
		));

file
function     int32 LoadPackageAsync

}

int32 LoadPackageAsync(const FPackagePath& InPackagePath, FLoadPackageAsyncOptionalParams InOptionalParams)
{
	LLM_SCOPE(ELLMTag::AsyncLoading);
	UE_CLOG(!GAsyncLoadingAllowed && !IsInAsyncLoadingThread(), LogStreaming, Fatal, TEXT("Requesting async load of \"%s\" when async loading is not allowed (after shutdown). Please fix higher level code."), *InPackagePath.GetDebugName());
#if DO_TRACK_ASYNC_LOAD_REQUESTS
	FTrackAsyncLoadRequests::Get().TrackRequest(InPackagePath.GetDebugName(), nullptr, InOptionalParams.PackagePriority);
#endif

file
function     int32 LoadPackageAsync

}

int32 LoadPackageAsync(const FPackagePath& InPackagePath,
		FName InPackageNameToCreate /* = NAME_None*/,
		FLoadPackageAsyncDelegate InCompletionDelegate /*= FLoadPackageAsyncDelegate()*/,
		EPackageFlags InPackageFlags /*= PKG_None*/,
		int32 InPIEInstanceID /*= INDEX_NONE*/,
		int32 InPackagePriority /*= 0*/,
		const FLinkerInstancingContext* InstancingContext /*=nullptr*/,

file
function     int32 LoadPackageAsync

}

int32 LoadPackageAsync(const FString& InName, const FGuid* InGuid /* nullptr*/)
{
	LLM_SCOPE(ELLMTag::AsyncLoading);
	FPackagePath PackagePath = GetLoadPackageAsyncPackagePath(InName);
	return LoadPackageAsync(PackagePath, NAME_None /* InPackageNameToCreate */, FLoadPackageAsyncDelegate(), PKG_None, INDEX_NONE, 0, nullptr);
}

int32 LoadPackageAsync(const FString& InName, FLoadPackageAsyncDelegate CompletionDelegate, int32 InPackagePriority /*= 0*/, EPackageFlags InPackageFlags /*= PKG_None*/, int32 InPIEInstanceID /*= INDEX_NONE*/)
{
	LLM_SCOPE(ELLMTag::AsyncLoading);
	FPackagePath PackagePath = GetLoadPackageAsyncPackagePath(InName);
	return LoadPackageAsync(PackagePath, NAME_None /* InPackageNameToCreate */, CompletionDelegate, InPackageFlags, InPIEInstanceID, InPackagePriority, nullptr);
}

int32 LoadPackageAsync(const FString& InName, FLoadPackageAsyncOptionalParams InOptionalParams)
{
	LLM_SCOPE(ELLMTag::AsyncLoading);
	FPackagePath PackagePath = GetLoadPackageAsyncPackagePath(InName);
	return LoadPackageAsync(PackagePath, MoveTemp(InOptionalParams));
}

int32 LoadPackageAsync(const FString& InName, const FGuid* InGuid /*= nullptr*/, const TCHAR* InPackageToLoadFrom, FLoadPackageAsyncDelegate InCompletionDelegate /*= FLoadPackageAsyncDelegate()*/, EPackageFlags InPackageFlags /*= PKG_None*/, int32 InPIEInstanceID /*= INDEX_NONE*/, int32 InPackagePriority /*= 0*/, const FLinkerInstancingContext* InstancingContext /*=nullptr*/)
{
	LLM_SCOPE(ELLMTag::AsyncLoading);
	FPackagePath PackagePath = GetLoadPackageAsyncPackagePath(InPackageToLoadFrom ? FStringView(InPackageToLoadFrom) : FStringView(InName));
	FName InPackageNameToCreate;
	if (InPackageToLoadFrom)
	{

file
function     int32 LoadPackageAsync

		}
	}
	return LoadPackageAsync(PackagePath, InPackageNameToCreate, MoveTemp(InCompletionDelegate), InPackageFlags, InPIEInstanceID, InPackagePriority, InstancingContext);
}

void CancelAsyncLoading()
{
	LLM_SCOPE(ELLMTag::AsyncLoading);
	// Cancelling async loading while loading is suspend will result in infinite stall

file
function     void ConditionalFlushAsyncLoadingForLinkers

		for (FLinkerLoad* Linker : InLinkers)
		{
			int32 Request = LoadPackageAsync(Linker->GetPackagePath(), FLoadPackageAsyncOptionalParams{ .PackagePriority = MAX_int32 });
			RequestIds.Add(Request);
		}
		FlushAsyncLoading(RequestIds);
	}
}

file
function     UPackage* LoadPackageInternal

			.LoadFlags = LoadFlags
		};
		int32 RequestID = LoadPackageAsync(PackagePath, MoveTemp(OptionalParams));

		if (RequestID != INDEX_NONE)
		{
			UE_SCOPED_IO_ACTIVITY(*WriteToString<512>(TEXT("Sync "), PackagePath.GetDebugName()));
			FlushAsyncLoading(RequestID);
		}

file
function     UPackage* LoadPackageInternal

			if (!Linker->AsyncRoot && LoadContext->GetBeginLoadCount() == 1 && IsInAsyncLoadingThread())
			{
				LoadPackageAsync(Linker->LinkerRoot->GetName());
			}
		}
		else
		{
			bFullyLoadSkipped = true;
		}

/**
 * Optional parameters passed to the LoadPackageAsync function.
 */
struct FLoadPackageAsyncOptionalParams
{
	/** If not none, this is the name of the package to load into (and create if not yet existing). If none, the name is take from PackagePath. **/
	FName CustomPackageName { NAME_None };
	/** Non Thread-safe delegate to be invoked from game-thread on completion. **/
	TUniquePtr<FLoadPackageAsyncDelegate> CompletionDelegate;
	/** Thread-safe delegate to be invoked at different state of progress for the given package. **/

 * @return Unique ID associated with this load request (the same package can be associated with multiple IDs).
 */
COREUOBJECT_API int32 LoadPackageAsync(const FPackagePath& InPackagePath, FLoadPackageAsyncOptionalParams InOptionalParams);

/**
 * Asynchronously load a package and all contained objects that match context flags. Non-blocking.
 * Use this version to specify the PackagePath rather than having the other versions internally convert the InName to a PackagePath by searching the current package mount points.
 * Use this version if you need to specify a packagename that is different from the packagename on disk; this is useful when loading multiple copies of the same package.
 *

 * @return Unique ID associated with this load request (the same package can be associated with multiple IDs).
 */
COREUOBJECT_API int32 LoadPackageAsync(const FPackagePath& InPackagePath, FName InPackageNameToCreate = NAME_None, FLoadPackageAsyncDelegate InCompletionDelegate = FLoadPackageAsyncDelegate(), EPackageFlags InPackageFlags = PKG_None, int32 InPIEInstanceID = INDEX_NONE, TAsyncLoadPriority InPackagePriority = 0, const FLinkerInstancingContext* InstancingContext = nullptr, uint32 LoadFlags = LOAD_None);

/**
 * Asynchronously load a package and all contained objects that match context flags. Non-blocking.
 * Use this version for convenience when you just need to load a package without notification and with default behavior from a packagename/filename.
 *
 * @param	InName					PackageName or LocalFilePath of package to load. Must be a mounted name/path. The package is created if it does not already exist.

 * @return Unique ID associated with this load request (the same package can be associated with multiple IDs).
 */
COREUOBJECT_API int32 LoadPackageAsync(const FString& InName, const FGuid* InGuid = nullptr);

/**
 * Asynchronously load a package and all contained objects that match context flags. Non-blocking.
 * Use this version when you need to load a package with default behavior from a packagename/filename, and need to be notified when it is loaded.
 *
 * @param	InName					PackageName or LocalFilePath of package to load. Must be a mounted name/path. The package is created if it does not already exist.

 * @return Unique ID associated with this load request (the same package can be associated with multiple IDs).
 */
COREUOBJECT_API int32 LoadPackageAsync(const FString& InName, FLoadPackageAsyncDelegate InCompletionDelegate, TAsyncLoadPriority InPackagePriority = 0, EPackageFlags InPackageFlags = PKG_None, int32 InPIEInstanceID = INDEX_NONE);

/**
 * Asynchronously load a package and all contained objects that match context flags. Non-blocking.
 * Use this version when you need to load a package with default behavior from a packagename/filename, and need to be notified when it is loaded.
 *
 * @param	InName                  PackageName or LocalFilePath of package to load. Must be a mounted name/path. The package is created if it does not already exist.

 * @return Unique ID associated with this load request (the same package can be associated with multiple IDs).
 */
COREUOBJECT_API int32 LoadPackageAsync(const FString& InName, FLoadPackageAsyncOptionalParams InOptionalParams);

/**
* Cancels all async package loading requests.
*/
COREUOBJECT_API void CancelAsyncLoading();

 * Blocks till a set of pending async load requests are complete.
 *
 * @param RequestIds list of return values from LoadPackageAsync to wait for. An empty list means all requests
 */
COREUOBJECT_API void FlushAsyncLoading(TConstArrayView<int32> RequestIds);

/**
 * Return number of active async load package requests
 */
COREUOBJECT_API int32 GetNumAsyncPackages();

/**
 * Returns whether we are currently loading a package (sync or async)

file
class        class FStringTableEngineBridge : public IStringTableEngineBridge, public FGCObject
function     virtual int32 LoadStringTableAssetImpl

				// Begin an asynchronous load
				// Note: The LoadPackageAsync callback may fire immediately if the request is invalid. This would remove the entry from AsyncLoadingStringTables, so it's valid for the find request below to fail in that case
				const int32 AsyncLoadingId = LoadPackageAsync(StringTableAssetPackageNameStr, FLoadPackageAsyncDelegate::CreateRaw(this, &FStringTableEngineBridge::HandleStringTableAssetAsyncLoadCompleted));

				if (AsyncLoadingId != INDEX_NONE)
				{
					// Load ongoing
					FScopeLock AsyncLoadingStringTablesLock(&AsyncLoadingStringTablesCS);
					if (FAsyncLoadingStringTable* AsyncLoadingState = AsyncLoadingStringTables.Find(StringTableAssetPackageName))

file
function     bool ULevelStreaming::RequestLevel

			{
				// When loading an instanced package we want to avoid it being processed as an asset so we make sure to set it RF_Transient.
				// If the package is not created here, it will get created by the LoadPackageAsync call. 
				// Gameworld packages (PIE) are already ignored so we can let LoadPackageAsync do its job.
				if (!bIsGameWorld)
				{
					UPackage* NewPackage = CreatePackage(*DesiredPackageName.ToString());
					NewPackage->SetFlags(RF_Transient);
				}

file
function     bool ULevelStreaming::RequestLevel

			}
#endif
			LoadPackageAsync(PackagePath, DesiredPackageName, FLoadPackageAsyncDelegate::CreateUObject(this, &ULevelStreaming::AsyncLevelLoadComplete), PackageFlags, PIEInstanceID, GetPriority(), InstancingContextPtr);

			// streamingServer: server loads everything?
			// Editor immediately blocks on load and we also block if background level streaming is disabled.
			if (BlockPolicy == AlwaysBlock || (ShouldBeAlwaysLoaded() && BlockPolicy != NeverBlock))
			{
				if (IsAsyncLoading())

file
function     bool FMaterialOverrideNanite::FixupLegacySoftReference

		const FString LongPackageName = OverrideMaterialRef.GetLongPackageName();
		UE_LOG(LogMaterial, Display, TEXT("Async loading NaniteOverrideMaterial '%s' for owner '%s'."), *LongPackageName, OptionalOwner ? *OptionalOwner->GetPathName() : TEXT("UNKNOWN"));
		LoadPackageAsync(LongPackageName, FLoadPackageAsyncDelegate::CreateLambda(
			[WeakOverrideMaterial = MakeWeakObjectPtr(OverrideMaterialEditor)](const FName&, UPackage*, EAsyncLoadingResult::Type)
			{
				if (UMaterialInterface* Material = WeakOverrideMaterial.Get())
				{
					// Use a MaterialUpdateContext to make sure dependent interfaces (e.g. MIDs) update as well
					FMaterialUpdateContext UpdateContext;

file
function     void FNetGUIDCache::StartAsyncLoadingPackage

	});

	LoadPackageAsync(CacheObject.PathName.ToString(), LoadPackageCompleteDelegate);
}

void FNetGUIDCache::AsyncPackageCallback(const FName& PackageName, UPackage* Package, EAsyncLoadingResult::Type Result)
{
	LLM_SCOPE_BYTAG(GuidCache);

file
function     void USoundNodeWavePlayer::LoadAsset

				UE_LOG(LogAudio, VeryVerbose, TEXT(" '%s:%s', Async loading..."), *GetNameSafe(GetOuter()), *GetName());
				bAsyncLoading = true;
				LoadPackageAsync(LongPackageName, FLoadPackageAsyncDelegate::CreateUObject(this, &USoundNodeWavePlayer::OnSoundWaveLoaded, bAddToRoot));
			}
		}
		else if (bAddToRoot)
		{
			SoundWave->AddToRoot();
		}

file
function     FStreamable* FStreamableManager::StreamInternal

#endif
				// This may overwrite an existing request id, this is intentional - see comment above re: cancellation
				Existing->RequestId = LoadPackageAsync(PackagePath,
					NAME_None /* PackageNameToCreate */,
					FLoadPackageAsyncDelegate::CreateSP(Handle, &FStreamableHandle::AsyncLoadCallbackWrapper, TargetName),
					PKG_None /* InPackageFlags */,
					INDEX_NONE /* InPIEInstanceID */,
					Priority /* InPackagePriority */);
			}

/**
 * This test demonstrate that LoadPackageAsync is thread-safe and can be called from multiple workers at the same time.
 */
IMPLEMENT_SIMPLE_AUTOMATION_TEST(FThreadSafeAsyncLoadingTest, TEXT(TEST_NAME_ROOT ".ThreadSafeAsyncLoadingTest"), EAutomationTestFlags::ClientContext | EAutomationTestFlags::EngineFilter)
bool FThreadSafeAsyncLoadingTest::RunTest(const FString& Parameters)
{
	// We use the asset registry to get a list of asset to load. 
	IAssetRegistry& AssetRegistry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(FName(TEXT("AssetRegistry"))).Get();
	AssetRegistry.WaitForCompletion();

file
function     bool FThreadSafeAsyncLoadingTest::RunTest
lambda-function

		[&PackagesToLoad, &RequestIDs](int32 Index)
		{
			RequestIDs[Index] = LoadPackageAsync(PackagesToLoad[Index].ToString());
		}
	);

	FlushAsyncLoading(RequestIDs);

	return true;

file
function     bool FConvertFromType_SoftToHard::RunTest

		UPackage* LoadedPackage = nullptr;
		UAsyncLoadingTests_ConvertFromType_V2* LoadedObject = nullptr;
		int32 RequestID = LoadPackageAsync(PackagePath1,
			FLoadPackageAsyncDelegate::CreateLambda(
				[&LoadedPackage, &LoadedObject, &ObjectName](const FName& InPackageName, UPackage* InLoadedPackage, EAsyncLoadingResult::Type InResult)
				{
					LoadedPackage = InLoadedPackage;
					LoadedObject  = FindObject<UAsyncLoadingTests_ConvertFromType_V2>(LoadedPackage, ObjectName);
				}

file
function     bool FLoadingTests_IsReadyForAsyncPostLoad::RunTest

	// Trigger the async loading
	int32 RequestId = LoadPackageAsync(FLoadingTestsScope::PackagePath1);

	// Wait for a good amount of time to make sure we're really timing out because bIsReadyForAsyncPostLoad is false.
	EAsyncPackageState::Type State = ProcessAsyncLoadingUntilComplete([&bPostLoadCalled]() { return bPostLoadCalled; }, 5.0);
	TestNotEqual("Async loading should not have been able to complete due to bIsReadyForAsyncPostLoad being false", State, EAsyncPackageState::Complete);
	TestFalse("No postload should have been called", bPostLoadCalled);

file
function     bool FLoadingTests_IsReadyForAsyncPostLoad_Flush::RunTest

	// Trigger the async loading
	int32 RequestId = LoadPackageAsync(FLoadingTestsScope::PackagePath1);

	// When a flush occurs, we have no choice but to ignore bIsReadyForAsyncPostLoad
	FlushAsyncLoading(RequestId);

	// Now we expect this to have completed in a timely manner
	TestTrue("Postload should have been called", bPostLoadCalled);

file
function     bool FLoadingTests_RecursiveLoads_FullFlushFrom_Serialize::RunTest

	// Create a request before starting the loading test so we get a request that is not tagged as partial.
	RequestId = LoadPackageAsync(FLoadingTestsScope::PackagePath2);

	LoadingTestScope.LoadObjects();

	return true;
}

file
function     bool FLoadingTests_RecursiveLoads_FullFlushFrom_PostLoad::RunTest

	// Create a request before starting the loading test so we get a request that is not tagged as partial.
	RequestId = LoadPackageAsync(FLoadingTestsScope::PackagePath2);

	LoadingTestScope.LoadObjects();

	return true;
}

file
function     bool FLoadingTests_Timeouts_Postload::RunTest

	// Trigger the async loading
	LoadPackageAsync(FLoadingTestsScope::PackagePath1);
	LoadPackageAsync(FLoadingTestsScope::PackagePath2);

	// Try to wait until all postload are finished but we're timing out after 1 seconds, which doesn't let enough time to process both postloads.
	EAsyncPackageState::Type State = ProcessAsyncLoadingUntilComplete([&PostLoadCount]() { return PostLoadCount == 2; }, 1.0);
	
	// The first call should have postloaded a single object and returned due to the elapse time.
	TestEqual("Async loading should have timed out", State, EAsyncPackageState::TimeOut);

file
namespace    UnattendedLoadTestImpl
class        class FUnattendedLoader
function     void LoadNextPackage

			{
				UE_LOG(LogTemp, Display, TEXT("Loading %s (Remaining: %d)"), *PackageName.ToString(), PackagesToLoad.Num());
				LoadPackageAsync(PackageName.ToString(),
					{
						.ProgressDelegate = MakeUnique<FLoadPackageAsyncProgressDelegate>(
							FLoadPackageAsyncProgressDelegate::CreateLambda(
								[this, ExecutionCheck = FExecutionCheck()](const FLoadPackageAsyncProgressParams& Params) mutable
								{
									// If we already triggered the next load from this callback, don't do anything else

/**
* Callback function used in UGameEngine::PrepareMapChange to pass to LoadPackageAsync.
*
* @param	LevelPackage	level package that finished async loading
* @param	InGameEngine	pointer to game engine object to associated loaded level with so it won't be GC'ed
*/
static void AsyncMapChangeLevelLoadCompletionCallback(const FName& PackageName, UPackage* LevelPackage, EAsyncLoadingResult::Type Result, FName InWorldHandle)
{
	FWorldContext &Context = GEngine->GetWorldContextFromHandleChecked( InWorldHandle );

	if( LevelPackage )
	{	
		// Try to find a UWorld object in the level package.

file
function     bool UEngine::PrepareMapChange

			STAT_ADD_CUSTOMMESSAGE_NAME( STAT_NamedMarker, *(FString( TEXT( "PrepareMapChange - " ) + LevelName.ToString() )) );
			TRACE_BOOKMARK(TEXT("PrepareMapChange - %s"), *LevelName.ToString());
			LoadPackageAsync(LevelName.ToString(),
				FLoadPackageAsyncDelegate::CreateStatic(&AsyncMapChangeLevelLoadCompletionCallback, Context.ContextHandle)
			);
		}

		return true;
	}

file
function     static void TickAssetLoadTest

			FString TestFile = AssetLoadTest_Filenames[IndexToDo];
			int32 CapturedNumProcessed = NumProcessed;
			LoadPackageAsync(TestFile, FLoadPackageAsyncDelegate::CreateLambda(
				[CapturedNumProcessed, bFirstTime](const FName& PackageName, UPackage* LoadedPackage, EAsyncLoadingResult::Type Result)
			{
				check(IsInGameThread());
				check(Result == EAsyncLoadingResult::Succeeded);
				UE_LOG(LogStreaming, Log, TEXT("UAssetLoadTest[%9d] - %s %s"), CapturedNumProcessed, bFirstTime ? TEXT("Loaded") : TEXT("Reloaded"), *PackageName.ToString());
				RequestsOutstanding--;

file
function     bool FSeamlessTravelHandler::StartLoadingMap

	if (FPackagePath::TryFromMountedName(MapPackageToLoadFrom, PackagePath))
	{
		LoadPackageAsync(
			PackagePath,
			PackageFName,
			FLoadPackageAsyncDelegate::CreateRaw(this, &FSeamlessTravelHandler::SeamlessTravelLoadCallback),
			PackageFlags,
			PIEInstanceID
		);

file
function     bool FWorldPartitionActorDescInstance::StartAsyncLoad

		const FPackagePath PackagePath = FPackagePath::FromPackageNameChecked(ActorPackage);

		AsyncLoadID = LoadPackageAsync(PackagePath, PackageName, FLoadPackageAsyncDelegate::CreateLambda([this, ActorPackage](const FName& PackageName, UPackage* Package, EAsyncLoadingResult::Type Result)
		{
			check(AsyncLoadID != INDEX_NONE);
			AsyncLoadID = INDEX_NONE;

			if ((Result != EAsyncLoadingResult::Succeeded) || !Package)
			{

file
function     bool FWorldPartitionLevelHelper::LoadActors

			const EPackageFlags PackageFlags = InParams.DestLevel->GetPackage()->HasAnyPackageFlags(PKG_PlayInEditor) ? PKG_PlayInEditor : PKG_None;
			const FPackagePath PackagePath = FPackagePath::FromPackageNameChecked(PackageToLoad);
			::LoadPackageAsync(PackagePath, PackageName, CompletionCallback, PackageFlags, DestPackage->GetPIEInstanceID(), 0, &ContainerInstancingContext);
		}
		else
		{
			UPackage* InstancingPackage = nullptr;
			if (PackageName != PackageToLoad)
			{

file
namespace    UE::Net::Private
function     void FObjectReferenceCache::StartAsyncLoadingPackage

	//DelinquentAsyncLoads.MaxConcurrentAsyncLoads = FMath::Max<uint32>(DelinquentAsyncLoads.MaxConcurrentAsyncLoads, PendingAsyncLoadRequests.Num());

	LoadPackageAsync(PackagePath.ToString(), FLoadPackageAsyncDelegate::CreateWeakLambda(ReplicationSystem, 
		[this](const FName& PackageName, UPackage* Package, EAsyncLoadingResult::Type Result)
		{
			AsyncPackageCallback(PackageName, Package, Result);
		}
	));
}

file
function     void UGameplayTagsManager::LoadGameplayTagTables

		for (FSoftObjectPath DataTablePath : MutableDefault->GameplayTagTableList)
		{
			LoadPackageAsync(DataTablePath.GetLongPackageName());
		}

		return;
	}
#endif // !WITH_EDITOR

file
function     void ALevelSequenceActor::PostLoad

		{
			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			// We intentionally do not attempt to load any asset in PostLoad other than by way of LoadPackageAsync
			// since under some circumstances it is possible for the sequence to only be partially loaded.
			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			LoadPackageAsync(LevelSequence_DEPRECATED.GetLongPackageName(), FLoadPackageAsyncDelegate::CreateUObject(this, &ALevelSequenceActor::OnSequenceLoaded));
		}
	}

	// Fix sprite component so that it's attached to the root component. In the past, the sprite component was the root component.
	UBillboardComponent* SpriteComponent = FindComponentByClass<UBillboardComponent>();
	if (SpriteComponent && SpriteComponent->GetAttachParent() != RootComponent)